From c8c400932c8151ab45c49b42eeb87ad3ac7b5cdd Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Tue, 19 Mar 2024 15:05:07 +0100 Subject: [PATCH 01/53] Unnecessary `@ComponentScan` Dupplicate code --- .../voltageinit/server/service/VoltageInitService.java | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitService.java b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitService.java index b0090f4a..d9a3c4f4 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitService.java @@ -6,15 +6,12 @@ */ package org.gridsuite.voltageinit.server.service; -import com.powsybl.network.store.client.NetworkStoreService; - import org.gridsuite.voltageinit.server.dto.ReactiveSlack; import org.gridsuite.voltageinit.server.dto.VoltageInitResult; import org.gridsuite.voltageinit.server.dto.VoltageInitStatus; import org.gridsuite.voltageinit.server.entities.VoltageInitResultEntity; import org.gridsuite.voltageinit.server.repository.VoltageInitResultRepository; import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.context.annotation.ComponentScan; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; @@ -25,7 +22,6 @@ /** * @author Etienne Homer */ -@ComponentScan(basePackageClasses = {NetworkStoreService.class}) @Service public class VoltageInitService { @Autowired From 2ddfc469bbdb2819cb75dbbc3b7d36c6405af2aa Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Tue, 19 Mar 2024 23:57:16 +0100 Subject: [PATCH 02/53] fix final root reporter --- .../service/VoltageInitWorkerService.java | 21 ++++++++++--------- .../server/VoltageInitParametersTest.java | 2 +- 2 files changed, 12 insertions(+), 11 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitWorkerService.java b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitWorkerService.java index 76955211..f42637b8 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitWorkerService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitWorkerService.java @@ -6,6 +6,7 @@ */ package org.gridsuite.voltageinit.server.service; +import com.google.common.annotations.VisibleForTesting; import com.google.common.collect.Sets; import com.powsybl.commons.PowsyblException; import com.powsybl.commons.reporter.Report; @@ -34,7 +35,10 @@ import org.springframework.web.server.ResponseStatusException; import java.util.*; -import java.util.concurrent.*; +import java.util.concurrent.CancellationException; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicReference; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; @@ -110,13 +114,13 @@ private Network getNetwork(UUID networkUuid, String variantId) { return network; } + @VisibleForTesting public static void addRestrictedVoltageLevelReport(Map voltageLevelsIdsRestricted, Reporter reporter) { if (!voltageLevelsIdsRestricted.isEmpty()) { String joinedVoltageLevelsIds = voltageLevelsIdsRestricted.entrySet() .stream() - .map(entry -> entry.getKey() + " : " + entry.getValue()) + .map(entry -> entry.getKey() + "=" + entry.getValue()) .collect(Collectors.joining(", ")); - reporter.report(Report.builder() .withKey("restrictedVoltageLevels") .withDefaultMessage(String.format("The modifications to the low limits for certain voltage levels have been restricted to avoid negative voltage limits: %s", joinedVoltageLevelsIds)) @@ -132,21 +136,19 @@ private OpenReacResult run(VoltageInitRunContext context, UUID resultUuid) throw Network network = voltageInitObserver.observe("network.load", () -> getNetwork(context.getNetworkUuid(), context.getVariantId())); - AtomicReference rootReporter = new AtomicReference<>(Reporter.NO_OP); - Reporter reporter = Reporter.NO_OP; if (context.getReportUuid() != null) { - String rootReporterId = context.getReporterId() == null ? VOLTAGE_INIT_TYPE_REPORT : context.getReporterId() + "@" + context.getReportType(); - rootReporter.set(new ReporterModel(rootReporterId, rootReporterId)); - reporter = rootReporter.get().createSubReporter(context.getReportType(), VOLTAGE_INIT_TYPE_REPORT, VOLTAGE_INIT_TYPE_REPORT, context.getReportUuid().toString()); // Delete any previous VoltageInit computation logs voltageInitObserver.observe("report.delete", () -> reportService.deleteReport(context.getReportUuid(), context.getReportType())); } CompletableFuture future = runVoltageInitAsync(context, network, resultUuid); if (context.getReportUuid() != null) { + final String rootReporterId = context.getReporterId() == null ? VOLTAGE_INIT_TYPE_REPORT : context.getReportType() + "@" + context.getReporterId(); + final Reporter rootReporter = new ReporterModel(rootReporterId, rootReporterId); + final Reporter reporter = rootReporter.createSubReporter(context.getReportType(), VOLTAGE_INIT_TYPE_REPORT, VOLTAGE_INIT_TYPE_REPORT, context.getReportUuid().toString()); addRestrictedVoltageLevelReport(context.getVoltageLevelsIdsRestricted(), reporter); voltageInitObserver.observe("report.send", () -> - reportService.sendReport(context.getReportUuid(), rootReporter.get())); + reportService.sendReport(context.getReportUuid(), rootReporter)); } return future == null ? null : voltageInitObserver.observeRun("run", future::get); @@ -158,7 +160,6 @@ public CompletableFuture runVoltageInitAsync(VoltageInitRunConte if (resultUuid != null && cancelComputationRequests.get(resultUuid) != null) { return null; } - OpenReacParameters parameters = voltageInitParametersService.buildOpenReacParameters(context, network); OpenReacConfig config = OpenReacConfig.load(); CompletableFuture future = OpenReacRunner.runAsync(network, network.getVariantManager().getWorkingVariantId(), parameters, config, voltageInitExecutionService.getComputationManager()); diff --git a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java index a7542ce0..17f90874 100644 --- a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java +++ b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java @@ -371,7 +371,7 @@ public void testAddRestrictedVoltageLevelReport() { ReporterModel reporter = new ReporterModel("test", "test"); VoltageInitWorkerService.addRestrictedVoltageLevelReport(restrictedVoltageLevel, reporter); assertEquals("restrictedVoltageLevels", reporter.getReports().stream().findFirst().get().getReportKey()); - assertEquals("The modifications to the low limits for certain voltage levels have been restricted to avoid negative voltage limits: vl : 10.0", + assertEquals("The modifications to the low limits for certain voltage levels have been restricted to avoid negative voltage limits: vl=10.0", reporter.getReports().stream().findFirst().get().getDefaultMessage()); Optional> typedValues = reporter.getReports().stream() .map(Report::getValues) From c6ede7969051ca3ce2f520b90696543027fbc00c Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Tue, 19 Mar 2024 23:46:13 +0100 Subject: [PATCH 03/53] simplify streams --- .../VoltageInitParametersService.java | 43 ++++++++++--------- 1 file changed, 23 insertions(+), 20 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index 1fee025d..bb11f31a 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -52,13 +52,13 @@ public UUID createParameters(VoltageInitParametersInfos parametersInfos) { } public Optional duplicateParameters(UUID sourceParametersId) { - Optional sourceVoltageInitParametersInfos = voltageInitParametersRepository.findById(sourceParametersId).map(VoltageInitParametersEntity::toVoltageInitParametersInfos); - if (sourceVoltageInitParametersInfos.isPresent()) { - VoltageInitParametersEntity entity = new VoltageInitParametersEntity(sourceVoltageInitParametersInfos.get()); - voltageInitParametersRepository.save(entity); - return Optional.of(entity.getId()); - } - return Optional.empty(); + return voltageInitParametersRepository.findById(sourceParametersId) + .map(VoltageInitParametersEntity::toVoltageInitParametersInfos) + .map(VoltageInitParametersEntity::new) + .map(entity -> { + voltageInitParametersRepository.save(entity); + return entity.getId(); + }); } public VoltageInitParametersInfos getParameters(UUID parametersUuid) { @@ -82,11 +82,14 @@ private Map resolveVoltageLevelLimits(VoltageInitRun Map voltageLevelLimits = new HashMap<>(); //each voltage level is associated to a voltage limit setting //if a voltage level is resolved by multiple filters the highest priority setting will be kept - voltageLimits.stream().forEach(voltageLimit -> - filterService.exportFilters(voltageLimit.getFilters().stream().map(FilterEquipmentsEmbeddable::getFilterId).toList(), context.getNetworkUuid(), context.getVariantId()) - .forEach(filterEquipment -> filterEquipment.getIdentifiableAttributes().stream().map(IdentifiableAttributes::getId) - .forEach(voltageLevelsId -> voltageLevelLimits.put(voltageLevelsId, voltageLimit)) - ) + voltageLimits.forEach(voltageLimit -> filterService.exportFilters( + voltageLimit.getFilters().stream().map(FilterEquipmentsEmbeddable::getFilterId).toList(), + context.getNetworkUuid(), context.getVariantId() + ).stream() + .map(FilterEquipments::getIdentifiableAttributes) + .flatMap(List::stream) + .map(IdentifiableAttributes::getId) + .forEach(voltageLevelsId -> voltageLevelLimits.put(voltageLevelsId, voltageLimit)) ); return voltageLevelLimits; } @@ -197,14 +200,14 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, private List toEquipmentIdsList(UUID networkUuid, String variantId, List filters) { if (filters == null || filters.isEmpty()) { return List.of(); + } else { + return filterService.exportFilters(filters.stream().map(FilterEquipmentsEmbeddable::getFilterId).toList(), networkUuid, variantId) + .stream() + .map(FilterEquipments::getIdentifiableAttributes) + .flatMap(List::stream) + .map(IdentifiableAttributes::getId) + .distinct() + .toList(); } - List equipments = filterService.exportFilters(filters.stream().map(FilterEquipmentsEmbeddable::getFilterId).toList(), networkUuid, variantId); - Set ids = new HashSet<>(); - equipments.forEach(filterEquipment -> - filterEquipment.getIdentifiableAttributes().forEach(identifiableAttribute -> - ids.add(identifiableAttribute.getId()) - ) - ); - return new ArrayList<>(ids); } } From bc03a8fd340e5bc5c3fce806fb3f00f2f2b29db8 Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Tue, 19 Mar 2024 23:48:38 +0100 Subject: [PATCH 04/53] simplify chrono --- .../parameters/VoltageInitParametersService.java | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index bb11f31a..ab7f7ba9 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -6,10 +6,6 @@ */ package org.gridsuite.voltageinit.server.service.parameters; -import java.util.*; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.atomic.AtomicReference; - import com.powsybl.iidm.network.Network; import com.powsybl.iidm.network.VoltageLevel; import com.powsybl.openreac.parameters.input.OpenReacParameters; @@ -29,6 +25,9 @@ import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; +import java.util.*; +import java.util.concurrent.TimeUnit; + /** * @author Ayoub LABIDI */ @@ -151,8 +150,7 @@ private void setHighVoltageLimit(List specificVoltageLimit @Transactional(readOnly = true) public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, Network network) { - AtomicReference startTime = new AtomicReference<>(); - startTime.set(System.nanoTime()); + final long startTime = System.nanoTime(); Optional voltageInitParametersEntity = Optional.empty(); if (context.getParametersUuid() != null) { @@ -192,8 +190,7 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, //The optimizer will attach reactive slack variables to all buses parameters.setReactiveSlackBusesMode(ReactiveSlackBusesMode.ALL); - long nanoTime = System.nanoTime(); - LOGGER.info("Parameters built in {}s", TimeUnit.NANOSECONDS.toSeconds(System.nanoTime() - startTime.getAndSet(nanoTime))); + LOGGER.info("Parameters built in {}s", TimeUnit.NANOSECONDS.toSeconds(System.nanoTime() - startTime)); return parameters; } From 70739ca08848e213ab6dd6ed63f19bdf002e68ba Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Wed, 20 Mar 2024 00:06:32 +0100 Subject: [PATCH 05/53] refactor voltage limits --- .../VoltageInitParametersService.java | 138 +++++++++--------- 1 file changed, 71 insertions(+), 67 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index ab7f7ba9..09893c74 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -10,6 +10,7 @@ import com.powsybl.iidm.network.VoltageLevel; import com.powsybl.openreac.parameters.input.OpenReacParameters; import com.powsybl.openreac.parameters.input.VoltageLimitOverride; +import com.powsybl.openreac.parameters.input.VoltageLimitOverride.VoltageLimitType; import com.powsybl.openreac.parameters.input.algo.ReactiveSlackBusesMode; import org.gridsuite.voltageinit.server.dto.parameters.FilterEquipments; import org.gridsuite.voltageinit.server.dto.parameters.IdentifiableAttributes; @@ -93,99 +94,102 @@ private Map resolveVoltageLevelLimits(VoltageInitRun return voltageLevelLimits; } - private void fillSpecificVoltageLimits(List specificVoltageLimits, Map voltageLevelModificationLimits, Map voltageLevelDefaultLimits, VoltageLevel voltageLevel, Map voltageLevelsIdsRestricted) { - boolean isLowVoltageLimitModificationSet = voltageLevelModificationLimits.containsKey(voltageLevel.getId()) && voltageLevelModificationLimits.get(voltageLevel.getId()).getLowVoltageLimit() != null; - boolean isHighVoltageLimitModificationSet = voltageLevelModificationLimits.containsKey(voltageLevel.getId()) && voltageLevelModificationLimits.get(voltageLevel.getId()).getHighVoltageLimit() != null; - boolean isLowVoltageLimitDefaultSet = voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) && voltageLevelDefaultLimits.get(voltageLevel.getId()).getLowVoltageLimit() != null; - boolean isHighVoltageLimitDefaultSet = voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) && voltageLevelDefaultLimits.get(voltageLevel.getId()).getHighVoltageLimit() != null; - - setLowVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isLowVoltageLimitModificationSet, isLowVoltageLimitDefaultSet, voltageLevel, voltageLevelsIdsRestricted); - setHighVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isHighVoltageLimitModificationSet, isHighVoltageLimitDefaultSet, voltageLevel); + private static void fillSpecificVoltageLimits(List specificVoltageLimits, + Map voltageLevelModificationLimits, + Map voltageLevelDefaultLimits, + VoltageLevel voltageLevel, + Map voltageLevelsIdsRestricted) { + if (voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) || voltageLevelModificationLimits.containsKey(voltageLevel.getId())) { + setLowVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, voltageLevel, voltageLevelsIdsRestricted); + setHighVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, voltageLevel); + } } - private void setLowVoltageLimit(List specificVoltageLimits, - Map voltageLevelModificationLimits, - Map voltageLevelDefaultLimits, - boolean isLowVoltageLimitModificationSet, - boolean isLowVoltageLimitDefaultSet, - VoltageLevel voltageLevel, - Map voltageLevelsIdsRestricted) { + private static void setLowVoltageLimit(List specificVoltageLimits, + Map voltageLevelModificationLimits, + Map voltageLevelDefaultLimits, + VoltageLevel voltageLevel, + Map voltageLevelsIdsRestricted) { + final String voltageLevelId = voltageLevel.getId(); + final boolean isLowVoltageLimitModificationSet = voltageLevelModificationLimits.containsKey(voltageLevelId) && voltageLevelModificationLimits.get(voltageLevelId).getLowVoltageLimit() != null; + final double lowVoltageLimit = voltageLevel.getLowVoltageLimit(); double newLowVoltageLimit; - double lowVoltageLimit = voltageLevel.getLowVoltageLimit(); if (!Double.isNaN(lowVoltageLimit) && isLowVoltageLimitModificationSet) { - double lowVoltageLimitModification = voltageLevelModificationLimits.get(voltageLevel.getId()).getLowVoltageLimit(); - + double lowVoltageLimitModification = voltageLevelModificationLimits.get(voltageLevelId).getLowVoltageLimit(); if (lowVoltageLimit + lowVoltageLimitModification < 0) { newLowVoltageLimit = lowVoltageLimit * -1; - voltageLevelsIdsRestricted.put(voltageLevel.getId(), newLowVoltageLimit); + voltageLevelsIdsRestricted.put(voltageLevelId, newLowVoltageLimit); } else { newLowVoltageLimit = lowVoltageLimitModification; } - specificVoltageLimits.add(new VoltageLimitOverride(voltageLevel.getId(), VoltageLimitOverride.VoltageLimitType.LOW_VOLTAGE_LIMIT, true, newLowVoltageLimit)); + specificVoltageLimits.add(new VoltageLimitOverride(voltageLevelId, VoltageLimitType.LOW_VOLTAGE_LIMIT, true, newLowVoltageLimit)); - } else if (Double.isNaN(lowVoltageLimit) && isLowVoltageLimitDefaultSet) { - double voltageLimit = voltageLevelDefaultLimits.get(voltageLevel.getId()).getLowVoltageLimit() + (isLowVoltageLimitModificationSet ? voltageLevelModificationLimits.get(voltageLevel.getId()).getLowVoltageLimit() : 0.); + } else if (Double.isNaN(lowVoltageLimit) + && voltageLevelDefaultLimits.containsKey(voltageLevelId) + && voltageLevelDefaultLimits.get(voltageLevelId).getLowVoltageLimit() != null) { + double voltageLimit = voltageLevelDefaultLimits.get(voltageLevelId).getLowVoltageLimit() + (isLowVoltageLimitModificationSet ? voltageLevelModificationLimits.get(voltageLevelId).getLowVoltageLimit() : 0.); if (voltageLimit < 0) { newLowVoltageLimit = 0.0; - voltageLevelsIdsRestricted.put(voltageLevel.getId(), newLowVoltageLimit); + voltageLevelsIdsRestricted.put(voltageLevelId, newLowVoltageLimit); } else { newLowVoltageLimit = voltageLimit; } - specificVoltageLimits.add( - new VoltageLimitOverride(voltageLevel.getId(), - VoltageLimitOverride.VoltageLimitType.LOW_VOLTAGE_LIMIT, - false, - newLowVoltageLimit - )); + specificVoltageLimits.add(new VoltageLimitOverride(voltageLevelId, VoltageLimitType.LOW_VOLTAGE_LIMIT, false, newLowVoltageLimit)); } } - private void setHighVoltageLimit(List specificVoltageLimits, Map voltageLevelModificationLimits, Map voltageLevelDefaultLimits, boolean isHighVoltageLimitModificationSet, boolean isHighVoltageLimitDefaultSet, VoltageLevel voltageLevel) { - if (!Double.isNaN(voltageLevel.getHighVoltageLimit()) && isHighVoltageLimitModificationSet) { - specificVoltageLimits.add(new VoltageLimitOverride(voltageLevel.getId(), VoltageLimitOverride.VoltageLimitType.HIGH_VOLTAGE_LIMIT, true, voltageLevelModificationLimits.get(voltageLevel.getId()).getHighVoltageLimit())); - } else if (Double.isNaN(voltageLevel.getHighVoltageLimit()) && isHighVoltageLimitDefaultSet) { - specificVoltageLimits.add(new VoltageLimitOverride(voltageLevel.getId(), VoltageLimitOverride.VoltageLimitType.HIGH_VOLTAGE_LIMIT, false, voltageLevelDefaultLimits.get(voltageLevel.getId()).getHighVoltageLimit() + (isHighVoltageLimitModificationSet ? voltageLevelModificationLimits.get(voltageLevel.getId()).getHighVoltageLimit() : 0.))); + private static void setHighVoltageLimit(List specificVoltageLimits, + Map voltageLevelModificationLimits, + Map voltageLevelDefaultLimits, + VoltageLevel voltageLevel) { + final String voltageLevelId = voltageLevel.getId(); + final boolean isHighVoltageLimitModificationSet = voltageLevelModificationLimits.containsKey(voltageLevelId) && voltageLevelModificationLimits.get(voltageLevelId).getHighVoltageLimit() != null; + final double highVoltageLimit = voltageLevel.getHighVoltageLimit(); + if (!Double.isNaN(highVoltageLimit) && isHighVoltageLimitModificationSet) { + specificVoltageLimits.add(new VoltageLimitOverride( + voltageLevelId, + VoltageLimitType.HIGH_VOLTAGE_LIMIT, + true, + voltageLevelModificationLimits.get(voltageLevelId).getHighVoltageLimit() + )); + } else if (Double.isNaN(highVoltageLimit) + && voltageLevelDefaultLimits.containsKey(voltageLevelId) + && voltageLevelDefaultLimits.get(voltageLevelId).getHighVoltageLimit() != null) { + specificVoltageLimits.add(new VoltageLimitOverride( + voltageLevelId, + VoltageLimitType.HIGH_VOLTAGE_LIMIT, + false, + voltageLevelDefaultLimits.get(voltageLevelId).getHighVoltageLimit() + (isHighVoltageLimitModificationSet ? voltageLevelModificationLimits.get(voltageLevelId).getHighVoltageLimit() : 0.) + )); } } @Transactional(readOnly = true) public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, Network network) { final long startTime = System.nanoTime(); - - Optional voltageInitParametersEntity = Optional.empty(); - if (context.getParametersUuid() != null) { - voltageInitParametersEntity = voltageInitParametersRepository.findById(context.getParametersUuid()); - } - OpenReacParameters parameters = new OpenReacParameters(); - List specificVoltageLimits = new ArrayList<>(); - List constantQGenerators = new ArrayList<>(); - List variableTwoWindingsTransformers = new ArrayList<>(); - List variableShuntCompensators = new ArrayList<>(); - - voltageInitParametersEntity.ifPresent(voltageInitParameters -> { - if (voltageInitParameters.getVoltageLimits() != null) { - Map voltageLevelDefaultLimits = resolveVoltageLevelLimits(context, voltageInitParameters.getVoltageLimits().stream() - .filter(voltageLimit -> VoltageLimitParameterType.DEFAULT.equals(voltageLimit.getVoltageLimitParameterType())) - .toList()); - - Map voltageLevelModificationLimits = resolveVoltageLevelLimits(context, voltageInitParameters.getVoltageLimits().stream() - .filter(voltageLimit -> VoltageLimitParameterType.MODIFICATION.equals(voltageLimit.getVoltageLimitParameterType())) - .toList()); - - network.getVoltageLevelStream() - .filter(voltageLevel -> voltageLevelDefaultLimits.keySet().contains(voltageLevel.getId()) || voltageLevelModificationLimits.keySet().contains(voltageLevel.getId())) - .forEach(voltageLevel -> fillSpecificVoltageLimits(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, voltageLevel, context.getVoltageLevelsIdsRestricted())); - } - constantQGenerators.addAll(toEquipmentIdsList(context.getNetworkUuid(), context.getVariantId(), voltageInitParameters.getConstantQGenerators())); - variableTwoWindingsTransformers.addAll(toEquipmentIdsList(context.getNetworkUuid(), context.getVariantId(), voltageInitParameters.getVariableTwoWindingsTransformers())); - variableShuntCompensators.addAll(toEquipmentIdsList(context.getNetworkUuid(), context.getVariantId(), voltageInitParameters.getVariableShuntCompensators())); - }); - parameters.addSpecificVoltageLimits(specificVoltageLimits) - .addConstantQGenerators(constantQGenerators) - .addVariableTwoWindingsTransformers(variableTwoWindingsTransformers) - .addVariableShuntCompensators(variableShuntCompensators); + Optional.ofNullable(context.getParametersUuid()) + .flatMap(voltageInitParametersRepository::findById) + .ifPresent(voltageInitParameters -> { + if (voltageInitParameters.getVoltageLimits() != null) { + final Map voltageLevelDefaultLimits = resolveVoltageLevelLimits(context, voltageInitParameters.getVoltageLimits() + .stream() + .filter(voltageLimit -> VoltageLimitParameterType.DEFAULT.equals(voltageLimit.getVoltageLimitParameterType())) + .toList()); + final Map voltageLevelModificationLimits = resolveVoltageLevelLimits(context, voltageInitParameters.getVoltageLimits() + .stream() + .filter(voltageLimit -> VoltageLimitParameterType.MODIFICATION.equals(voltageLimit.getVoltageLimitParameterType())) + .toList()); + List specificVoltageLimits = new LinkedList<>(); + network.getVoltageLevelStream() + .forEach(voltageLevel -> fillSpecificVoltageLimits(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, voltageLevel, context.getVoltageLevelsIdsRestricted())); + parameters.addSpecificVoltageLimits(specificVoltageLimits); + } + parameters.addConstantQGenerators(toEquipmentIdsList(context.getNetworkUuid(), context.getVariantId(), voltageInitParameters.getConstantQGenerators())) + .addVariableTwoWindingsTransformers(toEquipmentIdsList(context.getNetworkUuid(), context.getVariantId(), voltageInitParameters.getVariableTwoWindingsTransformers())) + .addVariableShuntCompensators(toEquipmentIdsList(context.getNetworkUuid(), context.getVariantId(), voltageInitParameters.getVariableShuntCompensators())); + }); //The optimizer will attach reactive slack variables to all buses parameters.setReactiveSlackBusesMode(ReactiveSlackBusesMode.ALL); From 508c5acb7785cb254976bf7ea1b90dd906260c8e Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Wed, 20 Mar 2024 12:00:25 +0100 Subject: [PATCH 06/53] fix cast --- .../service/VoltageInitResultContext.java | 26 +++++++++---------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitResultContext.java b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitResultContext.java index f072c673..cb0cbcc3 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitResultContext.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitResultContext.java @@ -45,11 +45,12 @@ public VoltageInitResultContext(UUID resultUuid, VoltageInitRunContext runContex } private static String getNonNullHeader(MessageHeaders headers, String name) { - String header = (String) headers.get(name); + final String header = headers.get(name, String.class); if (header == null) { throw new PowsyblException("Header '" + name + "' not found"); + } else { + return header; } - return header; } public static VoltageInitResultContext fromMessage(Message message) { @@ -57,17 +58,16 @@ public static VoltageInitResultContext fromMessage(Message message) { MessageHeaders headers = message.getHeaders(); UUID resultUuid = UUID.fromString(getNonNullHeader(headers, "resultUuid")); UUID networkUuid = UUID.fromString(getNonNullHeader(headers, "networkUuid")); - String variantId = (String) headers.get(VARIANT_ID_HEADER); - String receiver = (String) headers.get(HEADER_RECEIVER); - String userId = (String) headers.get(HEADER_USER_ID); - Map voltageLevelsIdsRestricted = (Map) headers.get(VOLTAGE_LEVELS_IDS_RESTRICTED); - - UUID parametersUuid = headers.containsKey(PARAMETERS_UUID_HEADER) ? UUID.fromString((String) headers.get(PARAMETERS_UUID_HEADER)) : null; - 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; - VoltageInitRunContext runContext = new VoltageInitRunContext(networkUuid, variantId, receiver, reportUuid, reporterId, reportType, userId, parametersUuid, voltageLevelsIdsRestricted); - return new VoltageInitResultContext(resultUuid, runContext); + String variantId = headers.get(VARIANT_ID_HEADER, String.class); + String receiver = headers.get(HEADER_RECEIVER, String.class); + String userId = headers.get(HEADER_USER_ID, String.class); + @SuppressWarnings("unchecked") + Map voltageLevelsIdsRestricted = headers.get(VOLTAGE_LEVELS_IDS_RESTRICTED, Map.class); + UUID parametersUuid = headers.containsKey(PARAMETERS_UUID_HEADER) ? UUID.fromString(headers.get(PARAMETERS_UUID_HEADER, String.class)) : null; + UUID reportUuid = headers.containsKey(REPORT_UUID_HEADER) ? UUID.fromString(headers.get(REPORT_UUID_HEADER, String.class)) : null; + String reporterId = headers.containsKey(REPORTER_ID_HEADER) ? headers.get(REPORTER_ID_HEADER, String.class) : null; + String reportType = headers.containsKey(REPORT_TYPE_HEADER) ? headers.get(REPORT_TYPE_HEADER, String.class) : null; + return new VoltageInitResultContext(resultUuid, new VoltageInitRunContext(networkUuid, variantId, receiver, reportUuid, reporterId, reportType, userId, parametersUuid, voltageLevelsIdsRestricted)); } public Message toMessage() { From 71180a9efc2b1ea20516db3bf911a013977039ed Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Wed, 20 Mar 2024 12:13:12 +0100 Subject: [PATCH 07/53] fix constructor --- .../server/service/VoltageInitRunContext.java | 22 ++++++++----------- .../server/service/VoltageInitService.java | 5 ++--- 2 files changed, 11 insertions(+), 16 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitRunContext.java b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitRunContext.java index dd3db658..472dcca5 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitRunContext.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitRunContext.java @@ -6,18 +6,22 @@ */ package org.gridsuite.voltageinit.server.service; -import lombok.Getter; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NonNull; +import java.util.HashMap; import java.util.Map; -import java.util.Objects; import java.util.UUID; /** * @author Etienne Homer */ -@Getter +@Data +@AllArgsConstructor public class VoltageInitRunContext { + @NonNull private final UUID networkUuid; private final String variantId; @@ -36,15 +40,7 @@ public class VoltageInitRunContext { private final Map voltageLevelsIdsRestricted; - public VoltageInitRunContext(UUID networkUuid, String variantId, String receiver, UUID reportUuid, String reporterId, String reportType, String userId, UUID parametersUuid, Map voltageLevelsIdsRestricted) { - this.networkUuid = Objects.requireNonNull(networkUuid); - this.variantId = variantId; - this.receiver = receiver; - this.reportUuid = reportUuid; - this.reporterId = reporterId; - this.reportType = reportType; - this.userId = userId; - this.parametersUuid = parametersUuid; - this.voltageLevelsIdsRestricted = voltageLevelsIdsRestricted; + public VoltageInitRunContext(@NonNull UUID networkUuid, String variantId, String receiver, UUID reportUuid, String reporterId, String reportType, String userId, UUID parametersUuid) { + this(networkUuid, variantId, receiver, reportUuid, reporterId, reportType, userId, parametersUuid, new HashMap<>()); } } diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitService.java b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitService.java index d9a3c4f4..74bddb7d 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitService.java @@ -45,9 +45,8 @@ public VoltageInitService(NotificationService notificationService, } public UUID runAndSaveResult(UUID networkUuid, String variantId, String receiver, UUID reportUuid, String reporterId, String userId, String reportType, UUID parametersUuid) { - VoltageInitRunContext runContext = new VoltageInitRunContext(networkUuid, variantId, receiver, reportUuid, reporterId, reportType, userId, parametersUuid, new HashMap<>()); - Objects.requireNonNull(runContext); - var resultUuid = uuidGeneratorService.generate(); + final VoltageInitRunContext runContext = new VoltageInitRunContext(networkUuid, variantId, receiver, reportUuid, reporterId, reportType, userId, parametersUuid); + final UUID resultUuid = uuidGeneratorService.generate(); // update status to running status setStatus(List.of(resultUuid), VoltageInitStatus.RUNNING.name()); From aff60c2c68144f29c4d71125b13eb862a385a948 Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Wed, 20 Mar 2024 21:04:39 +0100 Subject: [PATCH 08/53] migrate tests to junit5 --- pom.xml | 15 ---- .../server/SupervisionControllerTest.java | 15 ++-- .../server/VoltageInitControllerTest.java | 79 +++++++------------ .../server/VoltageInitParametersTest.java | 67 +++++++--------- .../service/ReportServiceTest.java | 38 ++++----- 5 files changed, 80 insertions(+), 134 deletions(-) diff --git a/pom.xml b/pom.xml index b9d89f57..bd0ba57a 100644 --- a/pom.xml +++ b/pom.xml @@ -189,31 +189,16 @@ powsybl-iidm-test test - - com.squareup.okhttp3 - okhttp - test - com.squareup.okhttp3 mockwebserver test - - junit - junit - test - org.assertj assertj-guava test - - org.junit.vintage - junit-vintage-engine - test - org.mockito mockito-core diff --git a/src/test/java/org/gridsuite/voltageinit/server/SupervisionControllerTest.java b/src/test/java/org/gridsuite/voltageinit/server/SupervisionControllerTest.java index b5beb596..f51e3899 100644 --- a/src/test/java/org/gridsuite/voltageinit/server/SupervisionControllerTest.java +++ b/src/test/java/org/gridsuite/voltageinit/server/SupervisionControllerTest.java @@ -6,35 +6,31 @@ */ package org.gridsuite.voltageinit.server; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.http.MediaType; -import org.springframework.test.context.junit4.SpringRunner; import org.springframework.test.web.servlet.MockMvc; import org.springframework.test.web.servlet.MvcResult; -import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; -import static org.junit.Assert.assertEquals; - /** * @author Hugo Marcellin */ -@RunWith(SpringRunner.class) @AutoConfigureMockMvc @SpringBootTest -public class SupervisionControllerTest { +class SupervisionControllerTest { @Autowired private MockMvc mockMvc; @Test - public void testResultCount() throws Exception { + void testResultCount() throws Exception { //get the result timeline uuid of the calculation MvcResult mvcResult = mockMvc.perform(get("/v1/supervision/results-count")) .andExpect(status().isOk()) @@ -43,7 +39,6 @@ public void testResultCount() throws Exception { String resultCount = mvcResult.getResponse().getContentAsString(); assertEquals("0", resultCount); - } } diff --git a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitControllerTest.java b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitControllerTest.java index a9c2401b..96b887a5 100644 --- a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitControllerTest.java +++ b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitControllerTest.java @@ -27,7 +27,6 @@ import com.powsybl.openreac.parameters.input.OpenReacParameters; import com.powsybl.openreac.parameters.output.OpenReacResult; import com.powsybl.openreac.parameters.output.OpenReacStatus; -import lombok.SneakyThrows; import okhttp3.HttpUrl; import okhttp3.mockwebserver.Dispatcher; import okhttp3.mockwebserver.MockResponse; @@ -44,13 +43,13 @@ import org.gridsuite.voltageinit.server.service.UuidGeneratorService; import org.gridsuite.voltageinit.server.service.parameters.FilterService; import org.gridsuite.voltageinit.server.util.annotations.PostCompletionAdapter; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.MockedStatic; import org.mockito.Mockito; -import org.mockito.MockitoAnnotations; +import org.mockito.junit.jupiter.MockitoExtension; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc; import org.springframework.boot.test.context.SpringBootTest; @@ -61,7 +60,6 @@ import org.springframework.messaging.Message; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.ContextHierarchy; -import org.springframework.test.context.junit4.SpringRunner; import org.springframework.test.web.servlet.MockMvc; import org.springframework.test.web.servlet.MvcResult; import org.springframework.transaction.support.TransactionSynchronizationManager; @@ -75,8 +73,8 @@ import static com.powsybl.network.store.model.NetworkStoreApi.VERSION; import static org.gridsuite.voltageinit.server.service.NotificationService.CANCEL_MESSAGE; import static org.gridsuite.voltageinit.server.service.NotificationService.HEADER_USER_ID; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.BDDMockito.given; @@ -87,12 +85,11 @@ /** * @author Etienne Homer */ -@RunWith(SpringRunner.class) +@ExtendWith({ MockitoExtension.class }) @AutoConfigureMockMvc @SpringBootTest @ContextHierarchy({@ContextConfiguration(classes = {VoltageInitApplication.class, TestChannelBinderConfiguration.class})}) -public class VoltageInitControllerTest { - +class VoltageInitControllerTest { private static final UUID NETWORK_UUID = UUID.fromString("7928181c-7977-4592-ba19-88027e4254e4"); private static final UUID OTHER_NETWORK_UUID = UUID.fromString("06824085-db85-4883-9458-8c5c9f1585d6"); private static final UUID RESULT_UUID = UUID.fromString("0c8de370-3e6c-4d72-b292-d355a97e0d5d"); @@ -130,21 +127,17 @@ public class VoltageInitControllerTest { @MockBean private UuidGeneratorService uuidGeneratorService; - private final RestTemplateConfig restTemplateConfig = new RestTemplateConfig(); - private final ObjectMapper mapper = restTemplateConfig.objectMapper(); + @Autowired + private ObjectMapper mapper; private Network network; - private Network network1; - private Network networkForMergingView; - private Network otherNetworkForMergingView; - OpenReacParameters openReacParameters; - OpenReacResult openReacResult; - CompletableFutureTask completableFutureResultsTask; + private OpenReacResult openReacResult; + private CompletableFutureTask completableFutureResultsTask; - private MockWebServer server; + public MockWebServer server; - private OpenReacResult buildOpenReacResult() { - OpenReacAmplIOFiles openReacAmplIOFiles = new OpenReacAmplIOFiles(openReacParameters, network, false); + private void buildOpenReacResult() { + OpenReacAmplIOFiles openReacAmplIOFiles = new OpenReacAmplIOFiles(new OpenReacParameters(), network, false); GeneratorModification.Modifs m1 = new GeneratorModification.Modifs(); m1.setTargetV(228.); @@ -161,10 +154,9 @@ private OpenReacResult buildOpenReacResult() { openReacAmplIOFiles.getNetworkModifications().getShuntModifications().add(new ShuntCompensatorModification("SHUNT_1", true, 1)); openReacResult = new OpenReacResult(OpenReacStatus.OK, openReacAmplIOFiles, INDICATORS); - return openReacResult; } - private VoltageInitParametersEntity buildVoltageInitParametersEntity() { + private static VoltageInitParametersEntity buildVoltageInitParametersEntity() { return VoltageInitParametersInfos.builder() .voltageLimitsModification(List.of(VoltageLimitInfos.builder() .priority(0) @@ -199,10 +191,8 @@ private VoltageInitParametersEntity buildVoltageInitParametersEntity() { .build().toEntity(); } - @Before + @BeforeEach public void setUp() throws Exception { - MockitoAnnotations.initMocks(this); - server = new MockWebServer(); server.start(); @@ -221,28 +211,21 @@ public void setUp() throws Exception { given(networkStoreService.getNetwork(NETWORK_UUID, PreloadingStrategy.COLLECTION)).willReturn(network); given(networkStoreService.getNetwork(OTHER_NETWORK_UUID, PreloadingStrategy.ALL_COLLECTIONS_NEEDED_FOR_BUS_VIEW)).willThrow(new PowsyblException("Not found")); - network1 = EurostagTutorialExample1Factory.createWithMoreGenerators(new NetworkFactoryImpl()); - network1.getVariantManager().cloneVariant(VariantManagerConstants.INITIAL_VARIANT_ID, VARIANT_2_ID); - // OpenReac run mocking - openReacParameters = new OpenReacParameters(); - openReacResult = buildOpenReacResult(); - + buildOpenReacResult(); completableFutureResultsTask = CompletableFutureTask.runAsync(() -> openReacResult, ForkJoinPool.commonPool()); // UUID service mocking to always generate the same result UUID given(uuidGeneratorService.generate()).willReturn(RESULT_UUID); final Dispatcher dispatcher = new Dispatcher() { - @SneakyThrows @Override public MockResponse dispatch(RecordedRequest request) { String path = Objects.requireNonNull(request.getPath()); - - if (path.matches("/v1/groups/.*") && request.getMethod().equals("DELETE")) { + if (path.matches("/v1/groups/.*") && "DELETE".equals(request.getMethod())) { return new MockResponse().setResponseCode(200) .addHeader("Content-Type", "application/json; charset=utf-8"); - } else if (path.matches("/v1/groups/modification") && request.getMethod().equals("POST")) { + } else if (path.matches("/v1/groups/modification") && "POST".equals(request.getMethod())) { return new MockResponse().setResponseCode(200).setBody("\"" + MODIFICATIONS_GROUP_UUID + "\"") .addHeader("Content-Type", "application/json; charset=utf-8"); } else if (path.matches("/v1/filters/export\\?networkUuid=" + NETWORK_UUID + "&variantId=" + VARIANT_2_ID + "&ids=.*")) { @@ -268,15 +251,15 @@ public MockResponse dispatch(RecordedRequest request) { } } - @SneakyThrows - @After - public void tearDown() { + @AfterEach + public void tearDown() throws Exception { mockMvc.perform(delete("/" + VERSION + "/results")) .andExpect(status().isOk()); + server.shutdown(); } @Test - public void runTest() throws Exception { + void runTest() throws Exception { try (MockedStatic openReacRunnerMockedStatic = Mockito.mockStatic(OpenReacRunner.class)) { openReacRunnerMockedStatic.when(() -> OpenReacRunner.runAsync(eq(network), eq(VARIANT_2_ID), any(OpenReacParameters.class), any(OpenReacConfig.class), any(ComputationManager.class))) .thenReturn(completableFutureResultsTask); @@ -339,7 +322,7 @@ public void runTest() throws Exception { } @Test - public void runWrongNetworkTest() throws Exception { + void runWrongNetworkTest() throws Exception { MvcResult result = mockMvc.perform(post( "/" + VERSION + "/networks/{networkUuid}/run-and-save?receiver=me&variantId=" + VARIANT_2_ID, OTHER_NETWORK_UUID) .header(HEADER_USER_ID, "userId")) @@ -360,7 +343,7 @@ public void runWrongNetworkTest() throws Exception { } @Test - public void runWithReportTest() throws Exception { + void runWithReportTest() throws Exception { MvcResult result = mockMvc.perform(post( "/" + VERSION + "/networks/{networkUuid}/run-and-save?receiver=me&variantId={variantId}&reportType=VoltageInit&reportUuid=" + REPORT_UUID + "&reporterId=" + UUID.randomUUID(), NETWORK_UUID, VARIANT_2_ID) .header(HEADER_USER_ID, "userId")) @@ -370,7 +353,7 @@ public void runWithReportTest() throws Exception { } @Test - public void stopTest() throws Exception { + void stopTest() throws Exception { try (MockedStatic openReacRunnerMockedStatic = Mockito.mockStatic(OpenReacRunner.class)) { openReacRunnerMockedStatic.when(() -> OpenReacRunner.runAsync(eq(network), eq(VARIANT_2_ID), any(OpenReacParameters.class), any(OpenReacConfig.class), any(ComputationManager.class))) .thenReturn(completableFutureResultsTask); @@ -396,9 +379,8 @@ public void stopTest() throws Exception { } } - @SneakyThrows @Test - public void getStatusTest() { + void getStatusTest() throws Exception { MvcResult result = mockMvc.perform(get( "/" + VERSION + "/results/{resultUuid}/status", RESULT_UUID)) .andExpect(status().isOk()) @@ -416,9 +398,8 @@ public void getStatusTest() { assertEquals(VoltageInitStatus.NOT_DONE.name(), result.getResponse().getContentAsString()); } - @SneakyThrows @Test - public void postCompletionAdapterTest() { + void postCompletionAdapterTest() { CompletableFutureTask task = CompletableFutureTask.runAsync(() -> openReacResult, ForkJoinPool.commonPool()); PostCompletionAdapter adapter = new PostCompletionAdapter(); adapter.execute(task); diff --git a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java index 17f90874..3d98dbb1 100644 --- a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java +++ b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java @@ -30,21 +30,18 @@ import org.gridsuite.voltageinit.server.entities.parameters.VoltageLimitEntity; import org.gridsuite.voltageinit.server.repository.parameters.VoltageInitParametersRepository; import org.gridsuite.voltageinit.server.service.VoltageInitRunContext; -import org.gridsuite.voltageinit.server.service.VoltageInitService; import org.gridsuite.voltageinit.server.service.VoltageInitWorkerService; import org.gridsuite.voltageinit.server.service.parameters.FilterService; import org.gridsuite.voltageinit.server.service.parameters.VoltageInitParametersService; import org.gridsuite.voltageinit.server.util.VoltageLimitParameterType; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.boot.test.mock.mockito.MockBean; import org.springframework.http.MediaType; -import org.springframework.test.context.junit4.SpringRunner; import org.springframework.test.web.servlet.MockMvc; import org.springframework.test.web.servlet.MvcResult; import org.springframework.transaction.annotation.Transactional; @@ -60,14 +57,11 @@ /** * @author Ayoub LABIDI */ -@RunWith(SpringRunner.class) @SpringBootTest @AutoConfigureMockMvc @Transactional -public class VoltageInitParametersTest { - +class VoltageInitParametersTest { private static final String URI_PARAMETERS_BASE = "/v1/parameters"; - private static final String URI_PARAMETERS_GET_PUT = URI_PARAMETERS_BASE + "/"; private static final UUID NETWORK_UUID = UUID.fromString("7928181c-7977-4592-ba19-88027e4254e4"); @@ -80,16 +74,13 @@ public class VoltageInitParametersTest { private Network network; @Autowired - VoltageInitService voltageInitService; + private VoltageInitParametersService voltageInitParametersService; @Autowired - VoltageInitParametersService voltageInitParametersService; + private MockMvc mockMvc; @Autowired - protected MockMvc mockMvc; - - @Autowired - protected ObjectMapper mapper; + private ObjectMapper mapper; @Autowired private VoltageInitParametersRepository parametersRepository; @@ -100,7 +91,7 @@ public class VoltageInitParametersTest { @MockBean private FilterService filterService; - @Before + @BeforeEach public void setup() { network = EurostagTutorialExample1Factory.create(new NetworkFactoryImpl()); network.getVariantManager().cloneVariant(VariantManagerConstants.INITIAL_VARIANT_ID, VARIANT_ID_1); @@ -130,13 +121,13 @@ public void setup() { parametersRepository.deleteAll(); } - @After + @AfterEach public void tearOff() { parametersRepository.deleteAll(); } @Test - public void testCreate() throws Exception { + void testCreate() throws Exception { VoltageInitParametersInfos parametersToCreate = buildParameters(); String parametersToCreateJson = mapper.writeValueAsString(parametersToCreate); @@ -150,11 +141,11 @@ public void testCreate() throws Exception { } @Test - public void testRead() throws Exception { + void testRead() throws Exception { VoltageInitParametersInfos parametersToRead = buildParameters(); - UUID parametersUuid = saveAndRetunId(parametersToRead); + UUID parametersUuid = saveAndReturnId(parametersToRead); MvcResult mvcResult = mockMvc.perform(get(URI_PARAMETERS_GET_PUT + parametersUuid)) .andExpect(status().isOk()).andReturn(); @@ -166,11 +157,11 @@ public void testRead() throws Exception { } @Test - public void testUpdate() throws Exception { + void testUpdate() throws Exception { VoltageInitParametersInfos parametersToUpdate = buildParameters(); - UUID parametersUuid = saveAndRetunId(parametersToUpdate); + UUID parametersUuid = saveAndReturnId(parametersToUpdate); parametersToUpdate = buildParametersUpdate(); @@ -185,11 +176,11 @@ public void testUpdate() throws Exception { } @Test - public void testDelete() throws Exception { + void testDelete() throws Exception { VoltageInitParametersInfos parametersToDelete = buildParameters(); - UUID parametersUuid = saveAndRetunId(parametersToDelete); + UUID parametersUuid = saveAndReturnId(parametersToDelete); mockMvc.perform(delete(URI_PARAMETERS_GET_PUT + parametersUuid)).andExpect(status().isOk()).andReturn(); @@ -199,14 +190,14 @@ public void testDelete() throws Exception { } @Test - public void testGetAll() throws Exception { + void testGetAll() throws Exception { VoltageInitParametersInfos parameters1 = buildParameters(); VoltageInitParametersInfos parameters2 = buildParametersUpdate(); - saveAndRetunId(parameters1); + saveAndReturnId(parameters1); - saveAndRetunId(parameters2); + saveAndReturnId(parameters2); MvcResult mvcResult = mockMvc.perform(get(URI_PARAMETERS_BASE)) .andExpect(status().isOk()).andReturn(); @@ -218,7 +209,7 @@ public void testGetAll() throws Exception { } @Test - public void testDuplicate() throws Exception { + void testDuplicate() throws Exception { VoltageInitParametersInfos parametersToCreate = buildParameters(); String parametersToCreateJson = mapper.writeValueAsString(parametersToCreate); @@ -239,12 +230,11 @@ public void testDuplicate() throws Exception { } /** Save parameters into the repository and return its UUID. */ - protected UUID saveAndRetunId(VoltageInitParametersInfos parametersInfos) { - parametersRepository.save(parametersInfos.toEntity()); - return parametersRepository.findAll().get(0).getId(); + private UUID saveAndReturnId(VoltageInitParametersInfos parametersInfos) { + return parametersRepository.save(parametersInfos.toEntity()).getId(); } - protected VoltageInitParametersInfos buildParameters() { + private static VoltageInitParametersInfos buildParameters() { return VoltageInitParametersInfos.builder() .voltageLimitsDefault(List.of()) .voltageLimitsModification(List.of()) @@ -265,7 +255,7 @@ protected VoltageInitParametersInfos buildParameters() { .build(); } - protected VoltageInitParametersInfos buildParametersUpdate() { + private static VoltageInitParametersInfos buildParametersUpdate() { return VoltageInitParametersInfos.builder() .voltageLimitsModification(List.of(VoltageLimitInfos.builder() .priority(0) @@ -300,7 +290,7 @@ protected VoltageInitParametersInfos buildParametersUpdate() { } @Test - public void testBuildSpecificVoltageLimits() { + void testBuildSpecificVoltageLimits() { VoltageLimitEntity voltageLimit = new VoltageLimitEntity(UUID.randomUUID(), 5., 10., 0, VoltageLimitParameterType.DEFAULT, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); VoltageLimitEntity voltageLimit2 = new VoltageLimitEntity(UUID.randomUUID(), 44., 88., 1, VoltageLimitParameterType.DEFAULT, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_2, FILTER_2))); @@ -310,7 +300,7 @@ public void testBuildSpecificVoltageLimits() { OpenReacParameters openReacParameters = voltageInitParametersService.buildOpenReacParameters(context, network); assertEquals(4, openReacParameters.getSpecificVoltageLimits().size()); //No override should be relative since there are no voltage limit modification - assertThat(openReacParameters.getSpecificVoltageLimits().stream().allMatch(voltageLimitOverride -> !voltageLimitOverride.isRelative())).isTrue(); + assertThat(openReacParameters.getSpecificVoltageLimits().stream().noneMatch(VoltageLimitOverride::isRelative)).isTrue(); //VLHV1, VLHV2 and VLLOAD should be applied default voltage limits since those are missing one or both limits assertThat(openReacParameters.getSpecificVoltageLimits().stream().anyMatch(voltageLimitOverride -> "VLHV1".equals(voltageLimitOverride.getVoltageLevelId()))).isTrue(); assertEquals(1, openReacParameters.getSpecificVoltageLimits().stream().filter(voltageLimitOverride -> "VLHV1".equals(voltageLimitOverride.getVoltageLevelId()) && VoltageLimitOverride.VoltageLimitType.LOW_VOLTAGE_LIMIT.equals(voltageLimitOverride.getVoltageLimitType())).count()); @@ -330,7 +320,7 @@ public void testBuildSpecificVoltageLimits() { context = new VoltageInitRunContext(NETWORK_UUID, VARIANT_ID_1, null, null, null, "", "", parametersRepository.findAll().get(1).getId(), new HashMap<>()); openReacParameters = voltageInitParametersService.buildOpenReacParameters(context, network); //There should nox be relative overrides since voltage limit modification are applied - assertThat(openReacParameters.getSpecificVoltageLimits().stream().allMatch(voltageLimitOverride -> !voltageLimitOverride.isRelative())).isFalse(); + assertThat(openReacParameters.getSpecificVoltageLimits().stream().noneMatch(VoltageLimitOverride::isRelative)).isFalse(); //Limits that weren't impacted by default settings are now impacted by modification settings assertEquals(8, openReacParameters.getSpecificVoltageLimits().size()); //VLGEN has both it limits set so it should now be impacted by modifications override @@ -365,7 +355,7 @@ public void testBuildSpecificVoltageLimits() { } @Test - public void testAddRestrictedVoltageLevelReport() { + void testAddRestrictedVoltageLevelReport() { Map restrictedVoltageLevel = new HashMap<>(); restrictedVoltageLevel.put("vl", 10.0); ReporterModel reporter = new ReporterModel("test", "test"); @@ -381,4 +371,3 @@ public void testAddRestrictedVoltageLevelReport() { assertEquals("WARN", typedValues.map(value -> value.getValue().getValue()).get()); } } - diff --git a/src/test/java/org/gridsuite/voltageinit/service/ReportServiceTest.java b/src/test/java/org/gridsuite/voltageinit/service/ReportServiceTest.java index ab1f9961..3c62d0a0 100644 --- a/src/test/java/org/gridsuite/voltageinit/service/ReportServiceTest.java +++ b/src/test/java/org/gridsuite/voltageinit/service/ReportServiceTest.java @@ -7,42 +7,38 @@ package org.gridsuite.voltageinit.service; import com.github.tomakehurst.wiremock.WireMockServer; -import com.github.tomakehurst.wiremock.core.WireMockConfiguration; import com.github.tomakehurst.wiremock.client.WireMock; - -import static com.github.tomakehurst.wiremock.client.WireMock.*; - +import com.github.tomakehurst.wiremock.core.WireMockConfiguration; import com.powsybl.commons.reporter.Reporter; import com.powsybl.commons.reporter.ReporterModel; import org.gridsuite.voltageinit.server.service.ReportService; import org.gridsuite.voltageinit.utils.ContextConfigurationWithTestChannel; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.boot.test.mock.mockito.MockBean; import org.springframework.http.*; -import org.springframework.test.context.junit4.SpringRunner; import org.springframework.web.client.RestTemplate; import org.springframework.web.util.UriComponentsBuilder; -import static org.gridsuite.voltageinit.utils.TestUtils.resourceToString; -import static org.mockito.ArgumentMatchers.eq; -import static org.mockito.Mockito.*; - import java.io.IOException; import java.net.URI; import java.util.UUID; +import static com.github.tomakehurst.wiremock.client.WireMock.*; +import static org.gridsuite.voltageinit.utils.TestUtils.resourceToString; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; + /** * @author Anis TOURI */ @SpringBootTest -@RunWith(SpringRunner.class) @ContextConfigurationWithTestChannel -public class ReportServiceTest { +class ReportServiceTest { private static final UUID REPORT_UUID = UUID.fromString("7928181c-7977-4592-ba19-88027e4254e4"); private static final String BASE_URI = "http://localhost:"; @@ -64,7 +60,7 @@ private void configureWireMockServer(String reportJson) { } - @Before + @BeforeEach public void setUp() throws IOException { String reportJson = resourceToString("/report.json"); server = new WireMockServer(WireMockConfiguration.wireMockConfig().dynamicPort()); @@ -76,23 +72,23 @@ public void setUp() throws IOException { reportService.setReportServiceBaseUri("http://localhost:" + server.port()); } - @After + @AfterEach public void tearDown() { server.stop(); } @Test - public void testSendReport() { + void testSendReport() { Reporter reporter = new ReporterModel("test", "test"); URI expectedUri = UriComponentsBuilder .fromPath(DELIMITER + REPORT_API_VERSION + "/reports/{reportUuid}") .build(REPORT_UUID); reportService.sendReport(REPORT_UUID, reporter); - verify(restTemplate, times(1)).put(eq(BASE_URI + server.port() + expectedUri), eq(reporter)); + verify(restTemplate, times(1)).put(BASE_URI + server.port() + expectedUri, reporter); } @Test - public void testDeleteReport() { + void testDeleteReport() { reportService.deleteReport(REPORT_UUID, "VoltageInit"); URI expectedUri = UriComponentsBuilder .fromPath(DELIMITER + REPORT_API_VERSION + "/reports/{reportUuid}") @@ -101,6 +97,6 @@ public void testDeleteReport() { .build(REPORT_UUID); HttpHeaders headers = new HttpHeaders(); headers.setContentType(MediaType.APPLICATION_JSON); - verify(restTemplate, times(1)).exchange(eq(BASE_URI + server.port() + expectedUri), eq(HttpMethod.DELETE), eq(new HttpEntity<>(headers)), eq(Void.class)); + verify(restTemplate, times(1)).exchange(BASE_URI + server.port() + expectedUri, HttpMethod.DELETE, new HttpEntity<>(headers), Void.class); } } From 44f827abae8b8eb866e6f3c2dc3ca58b1eb87e66 Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Thu, 21 Mar 2024 23:44:44 +0100 Subject: [PATCH 09/53] clean SpringBootTest --- .../voltageinit/server/VoltageInitControllerTest.java | 7 ++++--- .../voltageinit/server/VoltageInitParametersTest.java | 11 +++-------- 2 files changed, 7 insertions(+), 11 deletions(-) diff --git a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitControllerTest.java b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitControllerTest.java index 96b887a5..95503cca 100644 --- a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitControllerTest.java +++ b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitControllerTest.java @@ -58,6 +58,8 @@ import org.springframework.cloud.stream.binder.test.TestChannelBinderConfiguration; import org.springframework.http.MediaType; import org.springframework.messaging.Message; +import org.springframework.test.annotation.DirtiesContext; +import org.springframework.test.annotation.DirtiesContext.ClassMode; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.ContextHierarchy; import org.springframework.test.web.servlet.MockMvc; @@ -86,8 +88,9 @@ * @author Etienne Homer */ @ExtendWith({ MockitoExtension.class }) -@AutoConfigureMockMvc @SpringBootTest +@AutoConfigureMockMvc +@DirtiesContext(classMode = ClassMode.AFTER_EACH_TEST_METHOD) @ContextHierarchy({@ContextConfiguration(classes = {VoltageInitApplication.class, TestChannelBinderConfiguration.class})}) class VoltageInitControllerTest { private static final UUID NETWORK_UUID = UUID.fromString("7928181c-7977-4592-ba19-88027e4254e4"); @@ -253,8 +256,6 @@ public MockResponse dispatch(RecordedRequest request) { @AfterEach public void tearDown() throws Exception { - mockMvc.perform(delete("/" + VERSION + "/results")) - .andExpect(status().isOk()); server.shutdown(); } diff --git a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java index 3d98dbb1..f705c682 100644 --- a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java +++ b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java @@ -34,7 +34,6 @@ import org.gridsuite.voltageinit.server.service.parameters.FilterService; import org.gridsuite.voltageinit.server.service.parameters.VoltageInitParametersService; import org.gridsuite.voltageinit.server.util.VoltageLimitParameterType; -import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; @@ -42,6 +41,8 @@ import org.springframework.boot.test.context.SpringBootTest; import org.springframework.boot.test.mock.mockito.MockBean; import org.springframework.http.MediaType; +import org.springframework.test.annotation.DirtiesContext; +import org.springframework.test.annotation.DirtiesContext.ClassMode; import org.springframework.test.web.servlet.MockMvc; import org.springframework.test.web.servlet.MvcResult; import org.springframework.transaction.annotation.Transactional; @@ -58,6 +59,7 @@ * @author Ayoub LABIDI */ @SpringBootTest +@DirtiesContext(classMode = ClassMode.AFTER_EACH_TEST_METHOD) @AutoConfigureMockMvc @Transactional class VoltageInitParametersTest { @@ -117,13 +119,6 @@ public void setup() { equipmentsList2.add(new FilterEquipments(FILTER_UUID_2, FILTER_2, identifiableAttributes2, List.of())); given(filterService.exportFilters(List.of(FILTER_UUID_1), NETWORK_UUID, VARIANT_ID_1)).willReturn(equipmentsList1); given(filterService.exportFilters(List.of(FILTER_UUID_2), NETWORK_UUID, VARIANT_ID_1)).willReturn(equipmentsList2); - - parametersRepository.deleteAll(); - } - - @AfterEach - public void tearOff() { - parametersRepository.deleteAll(); } @Test From bd91ab1c5e2d03c6d0eb436e93f802efd00697cb Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Thu, 21 Mar 2024 23:52:34 +0100 Subject: [PATCH 10/53] prepare test --- .../server/VoltageInitParametersTest.java | 309 +++++++++--------- .../assertions/ReflectiveRepresentation.java | 30 ++ 2 files changed, 180 insertions(+), 159 deletions(-) create mode 100644 src/test/java/org/gridsuite/voltageinit/utils/assertions/ReflectiveRepresentation.java diff --git a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java index f705c682..f4d842db 100644 --- a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java +++ b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java @@ -21,6 +21,10 @@ import com.powsybl.network.store.iidm.impl.NetworkFactoryImpl; import com.powsybl.openreac.parameters.input.OpenReacParameters; import com.powsybl.openreac.parameters.input.VoltageLimitOverride; +import com.powsybl.openreac.parameters.input.VoltageLimitOverride.VoltageLimitType; +import org.apache.commons.lang3.builder.ToStringBuilder; +import org.assertj.core.api.Condition; +import org.assertj.core.api.ListAssert; import org.gridsuite.voltageinit.server.dto.parameters.FilterEquipments; import org.gridsuite.voltageinit.server.dto.parameters.IdentifiableAttributes; import org.gridsuite.voltageinit.server.dto.parameters.VoltageInitParametersInfos; @@ -35,7 +39,9 @@ import org.gridsuite.voltageinit.server.service.parameters.VoltageInitParametersService; import org.gridsuite.voltageinit.server.util.VoltageLimitParameterType; import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DynamicTest; import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc; import org.springframework.boot.test.context.SpringBootTest; @@ -48,9 +54,15 @@ import org.springframework.transaction.annotation.Transactional; import java.util.*; - +import java.util.function.Consumer; +import java.util.function.Function; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.condition.NestableCondition.nestable; +import static org.assertj.core.condition.VerboseCondition.verboseCondition; import static org.gridsuite.voltageinit.utils.assertions.Assertions.assertThat; -import static org.junit.jupiter.api.Assertions.*; import static org.mockito.BDDMockito.given; import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; @@ -72,6 +84,8 @@ class VoltageInitParametersTest { private static final UUID FILTER_UUID_2 = UUID.fromString("f5c30082-7a4f-11ee-b962-0242ac120002"); private static final String FILTER_1 = "FILTER_1"; private static final String FILTER_2 = "FILTER_2"; + private static final UUID REPORT_UUID = UUID.fromString("00000000-0000-0000-0000-000000000000"); + private Network network; @@ -95,138 +109,100 @@ class VoltageInitParametersTest { @BeforeEach public void setup() { + mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES); + network = EurostagTutorialExample1Factory.create(new NetworkFactoryImpl()); network.getVariantManager().cloneVariant(VariantManagerConstants.INITIAL_VARIANT_ID, VARIANT_ID_1); network.getVariantManager().setWorkingVariant(VARIANT_ID_1); given(networkStoreService.getNetwork(NETWORK_UUID, PreloadingStrategy.COLLECTION)).willReturn(network); - mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES); network.getVoltageLevel("VLGEN").setLowVoltageLimit(10.); network.getVoltageLevel("VLGEN").setHighVoltageLimit(20.); network.getVoltageLevel("VLHV1").setHighVoltageLimit(20.); network.getVoltageLevel("VLHV2").setLowVoltageLimit(10.); - List equipmentsList1 = new ArrayList<>(); - List identifiableAttributes = new ArrayList<>(); - identifiableAttributes.add(new IdentifiableAttributes("VLGEN", IdentifiableType.VOLTAGE_LEVEL, null)); - identifiableAttributes.add(new IdentifiableAttributes("VLHV1", IdentifiableType.VOLTAGE_LEVEL, null)); - identifiableAttributes.add(new IdentifiableAttributes("VLHV2", IdentifiableType.VOLTAGE_LEVEL, null)); - identifiableAttributes.add(new IdentifiableAttributes("VLLOAD", IdentifiableType.VOLTAGE_LEVEL, null)); - equipmentsList1.add(new FilterEquipments(FILTER_UUID_1, FILTER_1, identifiableAttributes, List.of())); - - List equipmentsList2 = new ArrayList<>(); - List identifiableAttributes2 = new ArrayList<>(); - identifiableAttributes2.add(new IdentifiableAttributes("VLLOAD", IdentifiableType.VOLTAGE_LEVEL, null)); - equipmentsList2.add(new FilterEquipments(FILTER_UUID_2, FILTER_2, identifiableAttributes2, List.of())); - given(filterService.exportFilters(List.of(FILTER_UUID_1), NETWORK_UUID, VARIANT_ID_1)).willReturn(equipmentsList1); - given(filterService.exportFilters(List.of(FILTER_UUID_2), NETWORK_UUID, VARIANT_ID_1)).willReturn(equipmentsList2); + given(filterService.exportFilters(List.of(FILTER_UUID_1), NETWORK_UUID, VARIANT_ID_1)).willReturn(List.of( + new FilterEquipments(FILTER_UUID_1, FILTER_1, List.of( + new IdentifiableAttributes("VLGEN", IdentifiableType.VOLTAGE_LEVEL, null), + new IdentifiableAttributes("VLHV1", IdentifiableType.VOLTAGE_LEVEL, null), + new IdentifiableAttributes("VLHV2", IdentifiableType.VOLTAGE_LEVEL, null), + new IdentifiableAttributes("VLLOAD", IdentifiableType.VOLTAGE_LEVEL, null) + ), List.of()) + )); + given(filterService.exportFilters(List.of(FILTER_UUID_2), NETWORK_UUID, VARIANT_ID_1)).willReturn(List.of( + new FilterEquipments(FILTER_UUID_2, FILTER_2, List.of(new IdentifiableAttributes("VLLOAD", IdentifiableType.VOLTAGE_LEVEL, null)), List.of()) + )); } @Test void testCreate() throws Exception { - VoltageInitParametersInfos parametersToCreate = buildParameters(); - String parametersToCreateJson = mapper.writeValueAsString(parametersToCreate); - - mockMvc.perform(post(URI_PARAMETERS_BASE).content(parametersToCreateJson).contentType(MediaType.APPLICATION_JSON)) - .andExpect(status().isOk()).andReturn(); - - VoltageInitParametersInfos createdParameters = parametersRepository.findAll().get(0).toVoltageInitParametersInfos(); - - assertThat(createdParameters).recursivelyEquals(parametersToCreate); + mockMvc.perform(post(URI_PARAMETERS_BASE).content(mapper.writeValueAsString(parametersToCreate)).contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()).andReturn(); + assertThat(parametersRepository.findAll().get(0).toVoltageInitParametersInfos()) + .as("created parameters") + .recursivelyEquals(parametersToCreate); } @Test void testRead() throws Exception { - VoltageInitParametersInfos parametersToRead = buildParameters(); - UUID parametersUuid = saveAndReturnId(parametersToRead); - MvcResult mvcResult = mockMvc.perform(get(URI_PARAMETERS_GET_PUT + parametersUuid)) - .andExpect(status().isOk()).andReturn(); + .andExpect(status().isOk()).andReturn(); String resultAsString = mvcResult.getResponse().getContentAsString(); - VoltageInitParametersInfos receivedParameters = mapper.readValue(resultAsString, new TypeReference<>() { - }); - - assertThat(receivedParameters).recursivelyEquals(parametersToRead); + assertThat(mapper.readValue(resultAsString, new TypeReference() {})) + .as("received parameters") + .recursivelyEquals(parametersToRead); } @Test void testUpdate() throws Exception { - - VoltageInitParametersInfos parametersToUpdate = buildParameters(); - - UUID parametersUuid = saveAndReturnId(parametersToUpdate); - - parametersToUpdate = buildParametersUpdate(); - - String parametersToUpdateJson = mapper.writeValueAsString(parametersToUpdate); - - mockMvc.perform(put(URI_PARAMETERS_GET_PUT + parametersUuid).content(parametersToUpdateJson).contentType(MediaType.APPLICATION_JSON)) - .andExpect(status().isOk()); - - VoltageInitParametersInfos updatedParameters = parametersRepository.findById(parametersUuid).get().toVoltageInitParametersInfos(); - - assertThat(updatedParameters).recursivelyEquals(parametersToUpdate); + UUID parametersUuid = saveAndReturnId(buildParameters()); + VoltageInitParametersInfos parametersToUpdate = buildParametersUpdate(); + mockMvc.perform(put(URI_PARAMETERS_GET_PUT + parametersUuid).content(mapper.writeValueAsString(parametersToUpdate)).contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()); + assertThat(parametersRepository.findById(parametersUuid).get().toVoltageInitParametersInfos()) + .as("updated parameters") + .recursivelyEquals(parametersToUpdate); } @Test void testDelete() throws Exception { - - VoltageInitParametersInfos parametersToDelete = buildParameters(); - - UUID parametersUuid = saveAndReturnId(parametersToDelete); - + UUID parametersUuid = saveAndReturnId(buildParameters()); mockMvc.perform(delete(URI_PARAMETERS_GET_PUT + parametersUuid)).andExpect(status().isOk()).andReturn(); - - List storedParameters = parametersRepository.findAll(); - - assertTrue(storedParameters.isEmpty()); + assertThat(parametersRepository.count()).as("parameters repository items count").isZero(); } @Test void testGetAll() throws Exception { - VoltageInitParametersInfos parameters1 = buildParameters(); - - VoltageInitParametersInfos parameters2 = buildParametersUpdate(); - - saveAndReturnId(parameters1); - - saveAndReturnId(parameters2); - + saveAndReturnId(buildParameters()); + saveAndReturnId(buildParametersUpdate()); MvcResult mvcResult = mockMvc.perform(get(URI_PARAMETERS_BASE)) - .andExpect(status().isOk()).andReturn(); + .andExpect(status().isOk()).andReturn(); String resultAsString = mvcResult.getResponse().getContentAsString(); - List receivedParameters = mapper.readValue(resultAsString, new TypeReference<>() { - }); - - assertThat(receivedParameters).hasSize(2); + assertThat(mapper.readValue(resultAsString, new TypeReference>() {})) + .as("received parameters") + .hasSize(2); } @Test void testDuplicate() throws Exception { - - VoltageInitParametersInfos parametersToCreate = buildParameters(); - String parametersToCreateJson = mapper.writeValueAsString(parametersToCreate); - mockMvc.perform(post(URI_PARAMETERS_BASE).content(parametersToCreateJson).contentType(MediaType.APPLICATION_JSON)) - .andExpect(status().isOk()).andReturn(); + mockMvc.perform(post(URI_PARAMETERS_BASE).content(mapper.writeValueAsString(buildParameters())).contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()).andReturn(); VoltageInitParametersInfos createdParameters = parametersRepository.findAll().get(0).toVoltageInitParametersInfos(); - - mockMvc.perform(post(URI_PARAMETERS_BASE) - .param("duplicateFrom", UUID.randomUUID().toString())) - .andExpect(status().isNotFound()); - - mockMvc.perform(post(URI_PARAMETERS_BASE) - .param("duplicateFrom", createdParameters.getUuid().toString())) - .andExpect(status().isOk()); - - VoltageInitParametersInfos duplicatedParameters = parametersRepository.findAll().get(1).toVoltageInitParametersInfos(); - assertThat(duplicatedParameters).recursivelyEquals(createdParameters); + mockMvc.perform(post(URI_PARAMETERS_BASE).param("duplicateFrom", UUID.randomUUID().toString())) + .andExpect(status().isNotFound()); + mockMvc.perform(post(URI_PARAMETERS_BASE).param("duplicateFrom", createdParameters.getUuid().toString())) + .andExpect(status().isOk()); + assertThat(parametersRepository.findAll().get(1).toVoltageInitParametersInfos()) + .as("duplicated parameters") + .recursivelyEquals(createdParameters); } /** Save parameters into the repository and return its UUID. */ private UUID saveAndReturnId(VoltageInitParametersInfos parametersInfos) { - return parametersRepository.save(parametersInfos.toEntity()).getId(); + parametersRepository.save(parametersInfos.toEntity()); + return parametersRepository.findAll().get(0).getId(); } private static VoltageInitParametersInfos buildParameters() { @@ -284,85 +260,100 @@ private static VoltageInitParametersInfos buildParametersUpdate() { .build(); } - @Test - void testBuildSpecificVoltageLimits() { - VoltageLimitEntity voltageLimit = new VoltageLimitEntity(UUID.randomUUID(), 5., 10., 0, VoltageLimitParameterType.DEFAULT, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); - VoltageLimitEntity voltageLimit2 = new VoltageLimitEntity(UUID.randomUUID(), 44., 88., 1, VoltageLimitParameterType.DEFAULT, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_2, FILTER_2))); - - VoltageInitParametersEntity voltageInitParameters = new VoltageInitParametersEntity(UUID.randomUUID(), null, "", List.of(voltageLimit, voltageLimit2), null, null, null); - parametersRepository.save(voltageInitParameters); - VoltageInitRunContext context = new VoltageInitRunContext(NETWORK_UUID, VARIANT_ID_1, null, null, null, "", "", parametersRepository.findAll().get(0).getId(), new HashMap<>()); - OpenReacParameters openReacParameters = voltageInitParametersService.buildOpenReacParameters(context, network); - assertEquals(4, openReacParameters.getSpecificVoltageLimits().size()); - //No override should be relative since there are no voltage limit modification - assertThat(openReacParameters.getSpecificVoltageLimits().stream().noneMatch(VoltageLimitOverride::isRelative)).isTrue(); - //VLHV1, VLHV2 and VLLOAD should be applied default voltage limits since those are missing one or both limits - assertThat(openReacParameters.getSpecificVoltageLimits().stream().anyMatch(voltageLimitOverride -> "VLHV1".equals(voltageLimitOverride.getVoltageLevelId()))).isTrue(); - assertEquals(1, openReacParameters.getSpecificVoltageLimits().stream().filter(voltageLimitOverride -> "VLHV1".equals(voltageLimitOverride.getVoltageLevelId()) && VoltageLimitOverride.VoltageLimitType.LOW_VOLTAGE_LIMIT.equals(voltageLimitOverride.getVoltageLimitType())).count()); - assertThat(openReacParameters.getSpecificVoltageLimits().stream().anyMatch(voltageLimitOverride -> "VLHV2".equals(voltageLimitOverride.getVoltageLevelId()))).isTrue(); - assertEquals(1, openReacParameters.getSpecificVoltageLimits().stream().filter(voltageLimitOverride -> "VLHV2".equals(voltageLimitOverride.getVoltageLevelId()) && VoltageLimitOverride.VoltageLimitType.HIGH_VOLTAGE_LIMIT.equals(voltageLimitOverride.getVoltageLimitType())).count()); - assertThat(openReacParameters.getSpecificVoltageLimits().stream().anyMatch(voltageLimitOverride -> "VLLOAD".equals(voltageLimitOverride.getVoltageLevelId()))).isTrue(); - assertEquals(1, openReacParameters.getSpecificVoltageLimits().stream().filter(voltageLimitOverride -> "VLLOAD".equals(voltageLimitOverride.getVoltageLevelId()) && VoltageLimitOverride.VoltageLimitType.LOW_VOLTAGE_LIMIT.equals(voltageLimitOverride.getVoltageLimitType())).count()); - assertEquals(1, openReacParameters.getSpecificVoltageLimits().stream().filter(voltageLimitOverride -> "VLLOAD".equals(voltageLimitOverride.getVoltageLevelId()) && VoltageLimitOverride.VoltageLimitType.HIGH_VOLTAGE_LIMIT.equals(voltageLimitOverride.getVoltageLimitType())).count()); - //The voltage limits attributed to VLLOAD should respectively be 44. and 88. since the priority of FILTER_2, related to VLLOAD, is higher than FILTER_1 - assertEquals(44., openReacParameters.getSpecificVoltageLimits().stream().filter(voltageLimitOverride -> "VLLOAD".equals(voltageLimitOverride.getVoltageLevelId()) && VoltageLimitOverride.VoltageLimitType.LOW_VOLTAGE_LIMIT.equals(voltageLimitOverride.getVoltageLimitType())).findAny().get().getLimit()); - assertEquals(88., openReacParameters.getSpecificVoltageLimits().stream().filter(voltageLimitOverride -> "VLLOAD".equals(voltageLimitOverride.getVoltageLevelId()) && VoltageLimitOverride.VoltageLimitType.HIGH_VOLTAGE_LIMIT.equals(voltageLimitOverride.getVoltageLimitType())).findAny().get().getLimit()); - - //We now add limit modifications in additions to defaults settings - VoltageLimitEntity voltageLimit3 = new VoltageLimitEntity(UUID.randomUUID(), -1., -2., 0, VoltageLimitParameterType.MODIFICATION, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); - voltageInitParameters.setVoltageLimits(List.of(voltageLimit, voltageLimit2, voltageLimit3)); - parametersRepository.save(voltageInitParameters); - context = new VoltageInitRunContext(NETWORK_UUID, VARIANT_ID_1, null, null, null, "", "", parametersRepository.findAll().get(1).getId(), new HashMap<>()); - openReacParameters = voltageInitParametersService.buildOpenReacParameters(context, network); - //There should nox be relative overrides since voltage limit modification are applied - assertThat(openReacParameters.getSpecificVoltageLimits().stream().noneMatch(VoltageLimitOverride::isRelative)).isFalse(); - //Limits that weren't impacted by default settings are now impacted by modification settings - assertEquals(8, openReacParameters.getSpecificVoltageLimits().size()); - //VLGEN has both it limits set so it should now be impacted by modifications override - assertEquals(-1., openReacParameters.getSpecificVoltageLimits().stream().filter(voltageLimitOverride -> "VLGEN".equals(voltageLimitOverride.getVoltageLevelId()) && VoltageLimitOverride.VoltageLimitType.LOW_VOLTAGE_LIMIT.equals(voltageLimitOverride.getVoltageLimitType())).findAny().get().getLimit()); - assertEquals(-2., openReacParameters.getSpecificVoltageLimits().stream().filter(voltageLimitOverride -> "VLGEN".equals(voltageLimitOverride.getVoltageLevelId()) && VoltageLimitOverride.VoltageLimitType.HIGH_VOLTAGE_LIMIT.equals(voltageLimitOverride.getVoltageLimitType())).findAny().get().getLimit()); - //Because of the modification setting the voltage limits attributed to VLLOAD should now respectively be 43. and 86. - assertEquals(43., openReacParameters.getSpecificVoltageLimits().stream().filter(voltageLimitOverride -> "VLLOAD".equals(voltageLimitOverride.getVoltageLevelId()) && VoltageLimitOverride.VoltageLimitType.LOW_VOLTAGE_LIMIT.equals(voltageLimitOverride.getVoltageLimitType())).findAny().get().getLimit()); - assertEquals(86., openReacParameters.getSpecificVoltageLimits().stream().filter(voltageLimitOverride -> "VLLOAD".equals(voltageLimitOverride.getVoltageLevelId()) && VoltageLimitOverride.VoltageLimitType.HIGH_VOLTAGE_LIMIT.equals(voltageLimitOverride.getVoltageLimitType())).findAny().get().getLimit()); + private static Consumer assertVoltageLimitOverride(final String levelId, final VoltageLimitType limitType) { + return assertVoltageLimitOverride(levelId, limitType, null); + } - // We need to check for the case of relative = true with the modification less than 0 => the new low voltage limit = low voltage limit * -1 - VoltageLimitEntity voltageLimit4 = new VoltageLimitEntity(UUID.randomUUID(), -20.0, 10.0, 0, VoltageLimitParameterType.MODIFICATION, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); - voltageInitParameters.setVoltageLimits(List.of(voltageLimit4)); - parametersRepository.save(voltageInitParameters); - context = new VoltageInitRunContext(NETWORK_UUID, VARIANT_ID_1, null, null, null, "", "", parametersRepository.findAll().get(2).getId(), new HashMap<>()); - openReacParameters = voltageInitParametersService.buildOpenReacParameters(context, network); - //There should have relative true overrides since voltage limit modification are applied for VLGEN - assertTrue(openReacParameters.getSpecificVoltageLimits().stream().filter(voltageLimitOverride -> "VLGEN".equals(voltageLimitOverride.getVoltageLevelId()) && VoltageLimitOverride.VoltageLimitType.LOW_VOLTAGE_LIMIT.equals(voltageLimitOverride.getVoltageLimitType())).map(VoltageLimitOverride::isRelative).findFirst().get()); - assertEquals(4, openReacParameters.getSpecificVoltageLimits().size()); - // The low voltage limit must be impacted by the modification of the value - assertEquals(-10., openReacParameters.getSpecificVoltageLimits().stream().filter(voltageLimitOverride -> "VLGEN".equals(voltageLimitOverride.getVoltageLevelId()) && VoltageLimitOverride.VoltageLimitType.LOW_VOLTAGE_LIMIT.equals(voltageLimitOverride.getVoltageLimitType())).findAny().get().getLimit()); + @SuppressWarnings("unchecked") + private static Consumer assertVoltageLimitOverride(final String levelId, final VoltageLimitType limitType, final Double limit) { + return voltageLimitOverride -> assertThat(voltageLimitOverride).as("voltageLimit override") + .is(nestable("VoltageLimitOverride", Stream.>of( + verboseCondition(actual -> levelId.equals(actual.getVoltageLevelId()), + "to have voltageLevelId=\"" + Objects.toString(levelId, "") + "\"", + actual -> " but is actually \"" + Objects.toString(actual.getVoltageLevelId(), "") + "\""), + verboseCondition(actual -> limitType.equals(actual.getVoltageLimitType()), + "to have voltageLimitType=\"" + Objects.toString(limitType, "") + "\"", + actual -> " but is actually \"" + Objects.toString(actual.getVoltageLimitType(), "") + "\""), + limit == null ? null : verboseCondition(actual -> limit.equals(actual.getLimit()), + "to have limit=" + limit, actual -> " but is actually " + actual.getLimit()) + ).filter(Objects::nonNull).toArray(Condition[]::new))); + } - // We need to check for the case of relative = false with the modification less than 0 => the new low voltage limit = 0 - VoltageLimitEntity voltageLimit5 = new VoltageLimitEntity(UUID.randomUUID(), 10.0, 10.0, 0, VoltageLimitParameterType.DEFAULT, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); - voltageInitParameters.setVoltageLimits(List.of(voltageLimit4, voltageLimit5)); - parametersRepository.save(voltageInitParameters); - context = new VoltageInitRunContext(NETWORK_UUID, VARIANT_ID_1, null, null, null, "", "", parametersRepository.findAll().get(3).getId(), new HashMap<>()); - openReacParameters = voltageInitParametersService.buildOpenReacParameters(context, network); - //There should have relative false overrides since voltage limit modification are applied for VLHV1 - assertFalse(openReacParameters.getSpecificVoltageLimits().stream().filter(voltageLimitOverride -> "VLHV1".equals(voltageLimitOverride.getVoltageLevelId()) && VoltageLimitOverride.VoltageLimitType.LOW_VOLTAGE_LIMIT.equals(voltageLimitOverride.getVoltageLimitType())).map(VoltageLimitOverride::isRelative).findFirst().get()); - // The low voltage limit must be impacted by the modification of the value - assertEquals(0., openReacParameters.getSpecificVoltageLimits().stream().filter(voltageLimitOverride -> "VLHV1".equals(voltageLimitOverride.getVoltageLevelId()) && VoltageLimitOverride.VoltageLimitType.LOW_VOLTAGE_LIMIT.equals(voltageLimitOverride.getVoltageLimitType())).findAny().get().getLimit()); + @TestFactory + List dynamicTestsBuildSpecificVoltageLimits() { + final Function, ListAssert> initTestEnv = (voltageLimits) -> { + final VoltageInitParametersEntity voltageInitParameters = parametersRepository.save( + new VoltageInitParametersEntity(UUID.randomUUID(), null, "", voltageLimits, null, null, null) + ); + final VoltageInitRunContext context = new VoltageInitRunContext(NETWORK_UUID, VARIANT_ID_1, null, REPORT_UUID, null, "", "", voltageInitParameters.getId()); + final OpenReacParameters openReacParameters = voltageInitParametersService.buildOpenReacParameters(context, network); + /*TODO*/System.out.println(parametersRepository.findAll().stream().map(ToStringBuilder::reflectionToString).collect(Collectors.joining())); + /*TODO*///System.out.println(mapper.writeValueAsString(context.getRootReporter())); + return assertThat(openReacParameters.getSpecificVoltageLimits()).as("SpecificVoltageLimits"); + }; + final VoltageLimitEntity voltageLimit = new VoltageLimitEntity(UUID.randomUUID(), 5., 10., 0, VoltageLimitParameterType.DEFAULT, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); + final VoltageLimitEntity voltageLimit2 = new VoltageLimitEntity(UUID.randomUUID(), 44., 88., 1, VoltageLimitParameterType.DEFAULT, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_2, FILTER_2))); + final VoltageLimitEntity voltageLimit3 = new VoltageLimitEntity(UUID.randomUUID(), -1., -2., 0, VoltageLimitParameterType.MODIFICATION, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); + final VoltageLimitEntity voltageLimit4 = new VoltageLimitEntity(UUID.randomUUID(), -20.0, 10.0, 0, VoltageLimitParameterType.MODIFICATION, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); + final VoltageLimitEntity voltageLimit5 = new VoltageLimitEntity(UUID.randomUUID(), 10.0, 10.0, 0, VoltageLimitParameterType.DEFAULT, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); + return List.of( + DynamicTest.dynamicTest("No voltage limit modification", () -> initTestEnv.apply(List.of(voltageLimit, voltageLimit2)) + .hasSize(4) + //No override should be relative since there is no voltage limit modification + .noneMatch(VoltageLimitOverride::isRelative) + //VLHV1, VLHV2 and VLLOAD should be applied default voltage limits since those are missing one or both limits + .satisfiesExactlyInAnyOrder( + assertVoltageLimitOverride("VLHV1", VoltageLimitType.LOW_VOLTAGE_LIMIT), + assertVoltageLimitOverride("VLHV2", VoltageLimitType.HIGH_VOLTAGE_LIMIT), + //The voltage limits attributed to VLLOAD should respectively be 44. and 88. since the priority of FILTER_2, related to VLLOAD, is higher than FILTER_1 + assertVoltageLimitOverride("VLLOAD", VoltageLimitType.LOW_VOLTAGE_LIMIT, 44.), + assertVoltageLimitOverride("VLLOAD", VoltageLimitType.HIGH_VOLTAGE_LIMIT, 88.) + )), + //We now add limit modifications in additions to defaults settings + DynamicTest.dynamicTest("With voltage limit modifications", () -> initTestEnv.apply(List.of(voltageLimit, voltageLimit2, voltageLimit3)) + //Limits that weren't impacted by default settings are now impacted by modification settings + .hasSize(8) + //There should (not?) be relative overrides since voltage limit modification are applied + .anyMatch(VoltageLimitOverride::isRelative) + //VLGEN has both it limits set so it should now be impacted by modifications override + .satisfiesOnlyOnce(assertVoltageLimitOverride("VLGEN", VoltageLimitType.LOW_VOLTAGE_LIMIT, -1.)) + .satisfiesOnlyOnce(assertVoltageLimitOverride("VLGEN", VoltageLimitType.HIGH_VOLTAGE_LIMIT, -2.)) + //Because of the modification setting the voltage limits attributed to VLLOAD should now respectively be 43. and 86. + .satisfiesOnlyOnce(assertVoltageLimitOverride("VLLOAD", VoltageLimitType.LOW_VOLTAGE_LIMIT, 43.)) + .satisfiesOnlyOnce(assertVoltageLimitOverride("VLLOAD", VoltageLimitType.HIGH_VOLTAGE_LIMIT, 86.))), + //note: VoltageLimitOverride implement equals() correctly, so we can use it + // We need to check for the case of relative = true with the modification less than 0 => the new low voltage limit = low voltage limit * -1 + DynamicTest.dynamicTest("Case relative true overrides", () -> initTestEnv.apply(List.of(voltageLimit4)) + .hasSize(4) + // isRelative: There should have relative true overrides since voltage limit modification are applied for VLGEN + // getLimit: The low voltage limit must be impacted by the modification of the value + .containsOnlyOnce(new VoltageLimitOverride("VLGEN", VoltageLimitType.LOW_VOLTAGE_LIMIT, true, -10.0))), + // We need to check for the case of relative = false with the modification less than 0 => the new low voltage limit = 0 + DynamicTest.dynamicTest("Case relative false overrides", () -> initTestEnv.apply(List.of(voltageLimit4, voltageLimit5)) + .hasSize(8) + // isRelative: There should have relative false overrides since voltage limit modification are applied for VLHV1 + // getLimit: The low voltage limit must be impacted by the modification of the value + .containsOnlyOnce(new VoltageLimitOverride("VLHV1", VoltageLimitType.LOW_VOLTAGE_LIMIT, false, 0.0))) + ); } @Test void testAddRestrictedVoltageLevelReport() { - Map restrictedVoltageLevel = new HashMap<>(); - restrictedVoltageLevel.put("vl", 10.0); + Map restrictedVoltageLevel = Map.of("vl", 10.0); ReporterModel reporter = new ReporterModel("test", "test"); VoltageInitWorkerService.addRestrictedVoltageLevelReport(restrictedVoltageLevel, reporter); - assertEquals("restrictedVoltageLevels", reporter.getReports().stream().findFirst().get().getReportKey()); - assertEquals("The modifications to the low limits for certain voltage levels have been restricted to avoid negative voltage limits: vl=10.0", - reporter.getReports().stream().findFirst().get().getDefaultMessage()); - Optional> typedValues = reporter.getReports().stream() - .map(Report::getValues) - .findFirst() + assertThat(reporter.getReports()).first() + .returns("restrictedVoltageLevels", Report::getReportKey) + .returns("The modifications to the low limits for certain voltage levels have been restricted to avoid negative voltage limits: vl=10.0", Report::getDefaultMessage); + + Optional> typedValues = reporter.getReports() + .stream() + .map(Report::getValues) //Stream> + .findFirst() //Optional> .flatMap(values -> values.entrySet().stream().findFirst()); - assertEquals("reportSeverity", typedValues.map(Map.Entry::getKey).get()); - assertEquals("WARN", typedValues.map(value -> value.getValue().getValue()).get()); + assertThat(typedValues.map(Map.Entry::getKey)).contains("reportSeverity"); + assertThat(typedValues.map(value -> value.getValue().getValue())).contains("WARN"); + + //TODO replace by json resource } } diff --git a/src/test/java/org/gridsuite/voltageinit/utils/assertions/ReflectiveRepresentation.java b/src/test/java/org/gridsuite/voltageinit/utils/assertions/ReflectiveRepresentation.java new file mode 100644 index 00000000..028f7c0b --- /dev/null +++ b/src/test/java/org/gridsuite/voltageinit/utils/assertions/ReflectiveRepresentation.java @@ -0,0 +1,30 @@ +package org.gridsuite.voltageinit.utils.assertions; + +import com.google.auto.service.AutoService; +import lombok.extern.slf4j.Slf4j; +import org.apache.commons.lang3.builder.ToStringBuilder; +import org.assertj.core.presentation.Representation; +import org.assertj.core.presentation.StandardRepresentation; +import org.jetbrains.annotations.NotNull; + +/** + * AssertJ {@link Representation} for types having no {@link Object#toString() toString()} implemented + */ +@AutoService(Representation.class) +@Slf4j +public class ReflectiveRepresentation extends StandardRepresentation { + /** + * {@inheritDoc} + */ + @Override + protected String fallbackToStringOf(@NotNull final Object object) { + try { + if (Object.class.equals(object.getClass().getMethod("toString").getDeclaringClass())) { + return ToStringBuilder.reflectionToString(object); + } + } catch (NoSuchMethodException e) { + log.warn("Error while analysing object class", e); + } + return object.toString(); + } +} From 71585a3e8e9e5a2ff41a97ee69a46690bc2bfc2a Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Fri, 22 Mar 2024 01:47:00 +0100 Subject: [PATCH 11/53] Add basic logs control --- .../server/VoltageInitParametersTest.java | 43 ++++++++++--------- .../service/ReportServiceTest.java | 6 +-- .../voltageinit/utils/TestUtils.java | 12 +++--- .../resources/report_case_relative_false.json | 23 ++++++++++ .../resources/report_case_relative_true.json | 23 ++++++++++ src/test/resources/report_empty.json | 7 +++ 6 files changed, 84 insertions(+), 30 deletions(-) create mode 100644 src/test/resources/report_case_relative_false.json create mode 100644 src/test/resources/report_case_relative_true.json create mode 100644 src/test/resources/report_empty.json diff --git a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java index f4d842db..4295b796 100644 --- a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java +++ b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java @@ -10,6 +10,7 @@ import com.fasterxml.jackson.databind.DeserializationFeature; import com.fasterxml.jackson.databind.ObjectMapper; import com.powsybl.commons.reporter.Report; +import com.powsybl.commons.reporter.Reporter; import com.powsybl.commons.reporter.ReporterModel; import com.powsybl.commons.reporter.TypedValue; import com.powsybl.iidm.network.IdentifiableType; @@ -38,10 +39,12 @@ import org.gridsuite.voltageinit.server.service.parameters.FilterService; import org.gridsuite.voltageinit.server.service.parameters.VoltageInitParametersService; import org.gridsuite.voltageinit.server.util.VoltageLimitParameterType; +import org.gridsuite.voltageinit.utils.TestUtils; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DynamicTest; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.TestFactory; +import org.skyscreamer.jsonassert.JSONAssert; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc; import org.springframework.boot.test.context.SpringBootTest; @@ -52,10 +55,13 @@ import org.springframework.test.web.servlet.MockMvc; import org.springframework.test.web.servlet.MvcResult; import org.springframework.transaction.annotation.Transactional; +import org.springframework.util.function.ThrowingBiFunction; -import java.util.*; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.UUID; import java.util.function.Consumer; -import java.util.function.Function; import java.util.stream.Collectors; import java.util.stream.Stream; @@ -281,14 +287,17 @@ private static Consumer assertVoltageLimitOverride(final S @TestFactory List dynamicTestsBuildSpecificVoltageLimits() { - final Function, ListAssert> initTestEnv = (voltageLimits) -> { + final ThrowingBiFunction, String, ListAssert> initTestEnv = (voltageLimits, reportFilename) -> { final VoltageInitParametersEntity voltageInitParameters = parametersRepository.save( new VoltageInitParametersEntity(UUID.randomUUID(), null, "", voltageLimits, null, null, null) ); final VoltageInitRunContext context = new VoltageInitRunContext(NETWORK_UUID, VARIANT_ID_1, null, REPORT_UUID, null, "", "", voltageInitParameters.getId()); final OpenReacParameters openReacParameters = voltageInitParametersService.buildOpenReacParameters(context, network); /*TODO*/System.out.println(parametersRepository.findAll().stream().map(ToStringBuilder::reflectionToString).collect(Collectors.joining())); - /*TODO*///System.out.println(mapper.writeValueAsString(context.getRootReporter())); + ReporterModel reporter = new ReporterModel("test", "test"); + VoltageInitWorkerService.addRestrictedVoltageLevelReport(context.getVoltageLevelsIdsRestricted(), reporter); + /*TODO*/System.out.println(mapper.writeValueAsString(reporter)); + JSONAssert.assertEquals("build parameters logs", TestUtils.resourceToString(reportFilename), mapper.writeValueAsString(reporter), false); return assertThat(openReacParameters.getSpecificVoltageLimits()).as("SpecificVoltageLimits"); }; final VoltageLimitEntity voltageLimit = new VoltageLimitEntity(UUID.randomUUID(), 5., 10., 0, VoltageLimitParameterType.DEFAULT, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); @@ -297,7 +306,7 @@ List dynamicTestsBuildSpecificVoltageLimits() { final VoltageLimitEntity voltageLimit4 = new VoltageLimitEntity(UUID.randomUUID(), -20.0, 10.0, 0, VoltageLimitParameterType.MODIFICATION, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); final VoltageLimitEntity voltageLimit5 = new VoltageLimitEntity(UUID.randomUUID(), 10.0, 10.0, 0, VoltageLimitParameterType.DEFAULT, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); return List.of( - DynamicTest.dynamicTest("No voltage limit modification", () -> initTestEnv.apply(List.of(voltageLimit, voltageLimit2)) + DynamicTest.dynamicTest("No voltage limit modification", () -> initTestEnv.apply(List.of(voltageLimit, voltageLimit2), "report_empty.json") .hasSize(4) //No override should be relative since there is no voltage limit modification .noneMatch(VoltageLimitOverride::isRelative) @@ -310,7 +319,7 @@ List dynamicTestsBuildSpecificVoltageLimits() { assertVoltageLimitOverride("VLLOAD", VoltageLimitType.HIGH_VOLTAGE_LIMIT, 88.) )), //We now add limit modifications in additions to defaults settings - DynamicTest.dynamicTest("With voltage limit modifications", () -> initTestEnv.apply(List.of(voltageLimit, voltageLimit2, voltageLimit3)) + DynamicTest.dynamicTest("With voltage limit modifications", () -> initTestEnv.apply(List.of(voltageLimit, voltageLimit2, voltageLimit3), "report_empty.json") //Limits that weren't impacted by default settings are now impacted by modification settings .hasSize(8) //There should (not?) be relative overrides since voltage limit modification are applied @@ -323,13 +332,13 @@ List dynamicTestsBuildSpecificVoltageLimits() { .satisfiesOnlyOnce(assertVoltageLimitOverride("VLLOAD", VoltageLimitType.HIGH_VOLTAGE_LIMIT, 86.))), //note: VoltageLimitOverride implement equals() correctly, so we can use it // We need to check for the case of relative = true with the modification less than 0 => the new low voltage limit = low voltage limit * -1 - DynamicTest.dynamicTest("Case relative true overrides", () -> initTestEnv.apply(List.of(voltageLimit4)) + DynamicTest.dynamicTest("Case relative true overrides", () -> initTestEnv.apply(List.of(voltageLimit4), "report_case_relative_true.json") .hasSize(4) // isRelative: There should have relative true overrides since voltage limit modification are applied for VLGEN // getLimit: The low voltage limit must be impacted by the modification of the value .containsOnlyOnce(new VoltageLimitOverride("VLGEN", VoltageLimitType.LOW_VOLTAGE_LIMIT, true, -10.0))), // We need to check for the case of relative = false with the modification less than 0 => the new low voltage limit = 0 - DynamicTest.dynamicTest("Case relative false overrides", () -> initTestEnv.apply(List.of(voltageLimit4, voltageLimit5)) + DynamicTest.dynamicTest("Case relative false overrides", () -> initTestEnv.apply(List.of(voltageLimit4, voltageLimit5), "report_case_relative_false.json") .hasSize(8) // isRelative: There should have relative false overrides since voltage limit modification are applied for VLHV1 // getLimit: The low voltage limit must be impacted by the modification of the value @@ -342,18 +351,10 @@ void testAddRestrictedVoltageLevelReport() { Map restrictedVoltageLevel = Map.of("vl", 10.0); ReporterModel reporter = new ReporterModel("test", "test"); VoltageInitWorkerService.addRestrictedVoltageLevelReport(restrictedVoltageLevel, reporter); - assertThat(reporter.getReports()).first() - .returns("restrictedVoltageLevels", Report::getReportKey) - .returns("The modifications to the low limits for certain voltage levels have been restricted to avoid negative voltage limits: vl=10.0", Report::getDefaultMessage); - - Optional> typedValues = reporter.getReports() - .stream() - .map(Report::getValues) //Stream> - .findFirst() //Optional> - .flatMap(values -> values.entrySet().stream().findFirst()); - assertThat(typedValues.map(Map.Entry::getKey)).contains("reportSeverity"); - assertThat(typedValues.map(value -> value.getValue().getValue())).contains("WARN"); - - //TODO replace by json resource + Reporter expected = new ReporterModel("test", "test"); + expected.report("restrictedVoltageLevels", + "The modifications to the low limits for certain voltage levels have been restricted to avoid negative voltage limits: vl=10.0", + Map.of(Report.REPORT_SEVERITY_KEY, TypedValue.WARN_SEVERITY)); + assertThat(reporter).usingRecursiveComparison().isEqualTo(expected); } } diff --git a/src/test/java/org/gridsuite/voltageinit/service/ReportServiceTest.java b/src/test/java/org/gridsuite/voltageinit/service/ReportServiceTest.java index 3c62d0a0..ef17a221 100644 --- a/src/test/java/org/gridsuite/voltageinit/service/ReportServiceTest.java +++ b/src/test/java/org/gridsuite/voltageinit/service/ReportServiceTest.java @@ -25,11 +25,11 @@ import java.io.IOException; import java.net.URI; +import java.net.URISyntaxException; import java.util.UUID; import static com.github.tomakehurst.wiremock.client.WireMock.*; import static org.gridsuite.voltageinit.utils.TestUtils.resourceToString; -import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; @@ -61,8 +61,8 @@ private void configureWireMockServer(String reportJson) { } @BeforeEach - public void setUp() throws IOException { - String reportJson = resourceToString("/report.json"); + public void setUp() throws IOException, URISyntaxException { + String reportJson = resourceToString("report.json"); server = new WireMockServer(WireMockConfiguration.wireMockConfig().dynamicPort()); server.start(); WireMock.configureFor("localhost", server.port()); diff --git a/src/test/java/org/gridsuite/voltageinit/utils/TestUtils.java b/src/test/java/org/gridsuite/voltageinit/utils/TestUtils.java index 20032d2c..11687425 100644 --- a/src/test/java/org/gridsuite/voltageinit/utils/TestUtils.java +++ b/src/test/java/org/gridsuite/voltageinit/utils/TestUtils.java @@ -7,11 +7,11 @@ package org.gridsuite.voltageinit.utils; -import com.google.common.io.ByteStreams; -import org.junit.platform.commons.util.StringUtils; - import java.io.IOException; +import java.net.URISyntaxException; import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Paths; /** * @author Anis Touri @@ -19,10 +19,10 @@ public final class TestUtils { private TestUtils() { + throw new RuntimeException("Utility class can't be instantiated"); } - public static String resourceToString(String resource) throws IOException { - String content = new String(ByteStreams.toByteArray(TestUtils.class.getResourceAsStream(resource)), StandardCharsets.UTF_8); - return StringUtils.replaceWhitespaceCharacters(content, ""); + public static String resourceToString(final String resource) throws IOException, URISyntaxException { + return Files.readString(Paths.get(ClassLoader.getSystemClassLoader().getResource(resource).toURI()), StandardCharsets.UTF_8).trim(); } } diff --git a/src/test/resources/report_case_relative_false.json b/src/test/resources/report_case_relative_false.json new file mode 100644 index 00000000..39cfa4d0 --- /dev/null +++ b/src/test/resources/report_case_relative_false.json @@ -0,0 +1,23 @@ +{ + "version": "1.0", + "reportTree": { + "taskKey": "test", + "reports": [ + { + "reportKey": "restrictedVoltageLevels", + "values": { + "reportSeverity": { + "value": "WARN", + "type": "SEVERITY" + } + } + } + ] + }, + "dics": { + "default": { + "restrictedVoltageLevels": "The modifications to the low limits for certain voltage levels have been restricted to avoid negative voltage limits: VLHV2=-10.0, VLHV1=0.0, VLGEN=-10.0, VLLOAD=0.0", + "test": "test" + } + } +} diff --git a/src/test/resources/report_case_relative_true.json b/src/test/resources/report_case_relative_true.json new file mode 100644 index 00000000..1975b5ed --- /dev/null +++ b/src/test/resources/report_case_relative_true.json @@ -0,0 +1,23 @@ +{ + "version": "1.0", + "reportTree": { + "taskKey": "test", + "reports": [ + { + "reportKey": "restrictedVoltageLevels", + "values": { + "reportSeverity": { + "value": "WARN", + "type": "SEVERITY" + } + } + } + ] + }, + "dics": { + "default": { + "restrictedVoltageLevels": "The modifications to the low limits for certain voltage levels have been restricted to avoid negative voltage limits: VLHV2=-10.0, VLGEN=-10.0", + "test": "test" + } + } +} diff --git a/src/test/resources/report_empty.json b/src/test/resources/report_empty.json new file mode 100644 index 00000000..599fb21f --- /dev/null +++ b/src/test/resources/report_empty.json @@ -0,0 +1,7 @@ +{ + "version": "1.0", + "reportTree": { "taskKey": "test" }, + "dics": { + "default": { "test": "test" } + } +} From 5ab800f9ae4460ba2ecb27a44604079dcfd00e6b Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Fri, 22 Mar 2024 01:03:58 +0100 Subject: [PATCH 12/53] Move reporter logs near building logic --- .../server/service/VoltageInitRunContext.java | 37 ++++++++++++------- .../service/VoltageInitWorkerService.java | 30 +-------------- .../VoltageInitParametersService.java | 31 +++++++++++++--- .../server/VoltageInitParametersTest.java | 33 ++++++----------- .../resources/report_case_relative_false.json | 35 +++++++++++++----- .../resources/report_case_relative_true.json | 35 +++++++++++++----- src/test/resources/report_empty.json | 20 +++++++++- 7 files changed, 130 insertions(+), 91 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitRunContext.java b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitRunContext.java index 472dcca5..d29d5516 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitRunContext.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitRunContext.java @@ -6,41 +6,52 @@ */ package org.gridsuite.voltageinit.server.service; -import lombok.AllArgsConstructor; +import com.powsybl.commons.reporter.Reporter; +import com.powsybl.commons.reporter.ReporterModel; import lombok.Data; -import lombok.NonNull; import java.util.HashMap; import java.util.Map; +import java.util.Objects; import java.util.UUID; /** * @author Etienne Homer */ @Data -@AllArgsConstructor public class VoltageInitRunContext { + private static final String VOLTAGE_INIT_TYPE_REPORT = "VoltageInit"; - @NonNull private final UUID networkUuid; - private final String variantId; - private final String receiver; - private final UUID reportUuid; - private final String reporterId; - private final String reportType; - private final String userId; - private final UUID parametersUuid; - private final Map voltageLevelsIdsRestricted; + private final Reporter rootReporter; + + public VoltageInitRunContext(UUID networkUuid, String variantId, String receiver, UUID reportUuid, String reporterId, String reportType, String userId, UUID parametersUuid, Map voltageLevelsIdsRestricted) { + this.networkUuid = Objects.requireNonNull(networkUuid); + this.variantId = variantId; + this.receiver = receiver; + this.reportUuid = reportUuid; + this.reporterId = reporterId; + this.reportType = reportType; + this.userId = userId; + this.parametersUuid = parametersUuid; + this.voltageLevelsIdsRestricted = voltageLevelsIdsRestricted; + if (this.reportUuid == null) { + this.rootReporter = Reporter.NO_OP; + } else { + final String rootReporterId = reporterId == null ? VOLTAGE_INIT_TYPE_REPORT : reporterId + "@" + reportType; + this.rootReporter = new ReporterModel(rootReporterId, rootReporterId); + } + } - public VoltageInitRunContext(@NonNull UUID networkUuid, String variantId, String receiver, UUID reportUuid, String reporterId, String reportType, String userId, UUID parametersUuid) { + public VoltageInitRunContext(UUID networkUuid, String variantId, String receiver, UUID reportUuid, String reporterId, String reportType, String userId, UUID parametersUuid) { this(networkUuid, variantId, receiver, reportUuid, reporterId, reportType, userId, parametersUuid, new HashMap<>()); } } diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitWorkerService.java b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitWorkerService.java index f42637b8..b415c45b 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitWorkerService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitWorkerService.java @@ -6,13 +6,8 @@ */ package org.gridsuite.voltageinit.server.service; -import com.google.common.annotations.VisibleForTesting; import com.google.common.collect.Sets; import com.powsybl.commons.PowsyblException; -import com.powsybl.commons.reporter.Report; -import com.powsybl.commons.reporter.Reporter; -import com.powsybl.commons.reporter.ReporterModel; -import com.powsybl.commons.reporter.TypedValue; import com.powsybl.iidm.network.Network; import com.powsybl.iidm.network.VariantManagerConstants; import com.powsybl.network.store.client.NetworkStoreService; @@ -43,7 +38,6 @@ import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; import java.util.function.Consumer; -import java.util.stream.Collectors; import static org.gridsuite.voltageinit.server.service.NotificationService.CANCEL_MESSAGE; import static org.gridsuite.voltageinit.server.service.NotificationService.FAIL_MESSAGE; @@ -53,14 +47,11 @@ */ @Service public class VoltageInitWorkerService { - private static final Logger LOGGER = LoggerFactory.getLogger(VoltageInitWorkerService.class); private static final String ERROR = "error"; private static final String ERROR_DURING_VOLTAGE_PROFILE_INITIALISATION = "Error during voltage profile initialization"; - private static final String VOLTAGE_INIT_TYPE_REPORT = "VoltageInit"; - private final NetworkStoreService networkStoreService; private final NetworkModificationService networkModificationService; @@ -114,21 +105,6 @@ private Network getNetwork(UUID networkUuid, String variantId) { return network; } - @VisibleForTesting - public static void addRestrictedVoltageLevelReport(Map voltageLevelsIdsRestricted, Reporter reporter) { - if (!voltageLevelsIdsRestricted.isEmpty()) { - String joinedVoltageLevelsIds = voltageLevelsIdsRestricted.entrySet() - .stream() - .map(entry -> entry.getKey() + "=" + entry.getValue()) - .collect(Collectors.joining(", ")); - reporter.report(Report.builder() - .withKey("restrictedVoltageLevels") - .withDefaultMessage(String.format("The modifications to the low limits for certain voltage levels have been restricted to avoid negative voltage limits: %s", joinedVoltageLevelsIds)) - .withSeverity(TypedValue.WARN_SEVERITY) - .build()); - } - } - private OpenReacResult run(VoltageInitRunContext context, UUID resultUuid) throws Exception { Objects.requireNonNull(context); @@ -143,12 +119,8 @@ private OpenReacResult run(VoltageInitRunContext context, UUID resultUuid) throw } CompletableFuture future = runVoltageInitAsync(context, network, resultUuid); if (context.getReportUuid() != null) { - final String rootReporterId = context.getReporterId() == null ? VOLTAGE_INIT_TYPE_REPORT : context.getReportType() + "@" + context.getReporterId(); - final Reporter rootReporter = new ReporterModel(rootReporterId, rootReporterId); - final Reporter reporter = rootReporter.createSubReporter(context.getReportType(), VOLTAGE_INIT_TYPE_REPORT, VOLTAGE_INIT_TYPE_REPORT, context.getReportUuid().toString()); - addRestrictedVoltageLevelReport(context.getVoltageLevelsIdsRestricted(), reporter); voltageInitObserver.observe("report.send", () -> - reportService.sendReport(context.getReportUuid(), rootReporter)); + reportService.sendReport(context.getReportUuid(), context.getRootReporter())); } return future == null ? null : voltageInitObserver.observeRun("run", future::get); diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index 09893c74..4a84b7d2 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -6,6 +6,9 @@ */ package org.gridsuite.voltageinit.server.service.parameters; +import com.powsybl.commons.reporter.Report; +import com.powsybl.commons.reporter.Reporter; +import com.powsybl.commons.reporter.TypedValue; import com.powsybl.iidm.network.Network; import com.powsybl.iidm.network.VoltageLevel; import com.powsybl.openreac.parameters.input.OpenReacParameters; @@ -28,6 +31,7 @@ import java.util.*; import java.util.concurrent.TimeUnit; +import java.util.stream.Collectors; /** * @author Ayoub LABIDI @@ -35,11 +39,9 @@ @Service public class VoltageInitParametersService { - private static final Logger LOGGER = LoggerFactory.getLogger(VoltageInitParametersService.class); private final FilterService filterService; - private final VoltageInitParametersRepository voltageInitParametersRepository; public VoltageInitParametersService(VoltageInitParametersRepository voltageInitParametersRepository, FilterService filterService) { @@ -167,11 +169,14 @@ private static void setHighVoltageLimit(List specificVolta @Transactional(readOnly = true) public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, Network network) { final long startTime = System.nanoTime(); - OpenReacParameters parameters = new OpenReacParameters(); + final OpenReacParameters parameters = new OpenReacParameters(); + final Reporter reporter = context.getRootReporter().createSubReporter("OpenReactParameters", "OpenReact parameters", Map.of( + "parameters_id", new TypedValue(Objects.toString(context.getParametersUuid()), "ID") + )); Optional.ofNullable(context.getParametersUuid()) .flatMap(voltageInitParametersRepository::findById) - .ifPresent(voltageInitParameters -> { + .ifPresentOrElse(voltageInitParameters -> { if (voltageInitParameters.getVoltageLimits() != null) { final Map voltageLevelDefaultLimits = resolveVoltageLevelLimits(context, voltageInitParameters.getVoltageLimits() .stream() @@ -185,11 +190,27 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, network.getVoltageLevelStream() .forEach(voltageLevel -> fillSpecificVoltageLimits(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, voltageLevel, context.getVoltageLevelsIdsRestricted())); parameters.addSpecificVoltageLimits(specificVoltageLimits); + if (!context.getVoltageLevelsIdsRestricted().isEmpty()) { + reporter.report(Report.builder() + .withKey("restrictedVoltageLevels") + .withDefaultMessage("The modifications to the low limits for certain voltage levels have been restricted to avoid negative voltage limits: ${joinedVoltageLevelsIds}") + .withValue("joinedVoltageLevelsIds", context.getVoltageLevelsIdsRestricted() + .entrySet() + .stream() + .map(entry -> entry.getKey() + "=" + entry.getValue()) + .collect(Collectors.joining(", "))) + .withSeverity(TypedValue.WARN_SEVERITY) + .build()); + } } parameters.addConstantQGenerators(toEquipmentIdsList(context.getNetworkUuid(), context.getVariantId(), voltageInitParameters.getConstantQGenerators())) .addVariableTwoWindingsTransformers(toEquipmentIdsList(context.getNetworkUuid(), context.getVariantId(), voltageInitParameters.getVariableTwoWindingsTransformers())) .addVariableShuntCompensators(toEquipmentIdsList(context.getNetworkUuid(), context.getVariantId(), voltageInitParameters.getVariableShuntCompensators())); - }); + }, () -> reporter.report(Report.builder() + .withKey("noParameters") + .withDefaultMessage("No parameters were found for this analysis: using default parameters.") + .withSeverity(TypedValue.TRACE_SEVERITY) + .build())); //The optimizer will attach reactive slack variables to all buses parameters.setReactiveSlackBusesMode(ReactiveSlackBusesMode.ALL); diff --git a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java index 4295b796..a4d102e1 100644 --- a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java +++ b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java @@ -9,10 +9,6 @@ import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.DeserializationFeature; import com.fasterxml.jackson.databind.ObjectMapper; -import com.powsybl.commons.reporter.Report; -import com.powsybl.commons.reporter.Reporter; -import com.powsybl.commons.reporter.ReporterModel; -import com.powsybl.commons.reporter.TypedValue; import com.powsybl.iidm.network.IdentifiableType; import com.powsybl.iidm.network.Network; import com.powsybl.iidm.network.VariantManagerConstants; @@ -35,7 +31,6 @@ import org.gridsuite.voltageinit.server.entities.parameters.VoltageLimitEntity; import org.gridsuite.voltageinit.server.repository.parameters.VoltageInitParametersRepository; import org.gridsuite.voltageinit.server.service.VoltageInitRunContext; -import org.gridsuite.voltageinit.server.service.VoltageInitWorkerService; import org.gridsuite.voltageinit.server.service.parameters.FilterService; import org.gridsuite.voltageinit.server.service.parameters.VoltageInitParametersService; import org.gridsuite.voltageinit.server.util.VoltageLimitParameterType; @@ -44,7 +39,11 @@ import org.junit.jupiter.api.DynamicTest; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.TestFactory; +import org.skyscreamer.jsonassert.Customization; import org.skyscreamer.jsonassert.JSONAssert; +import org.skyscreamer.jsonassert.JSONCompareMode; +import org.skyscreamer.jsonassert.comparator.CustomComparator; +import org.skyscreamer.jsonassert.comparator.JSONComparator; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc; import org.springframework.boot.test.context.SpringBootTest; @@ -58,7 +57,6 @@ import org.springframework.util.function.ThrowingBiFunction; import java.util.List; -import java.util.Map; import java.util.Objects; import java.util.UUID; import java.util.function.Consumer; @@ -92,6 +90,11 @@ class VoltageInitParametersTest { private static final String FILTER_2 = "FILTER_2"; private static final UUID REPORT_UUID = UUID.fromString("00000000-0000-0000-0000-000000000000"); + private static final JSONComparator reporterComparator = new CustomComparator(JSONCompareMode.STRICT, + // ignore field having uuid changing each run + new Customization("reportTree.subReporters[*].taskValues.parameters_id.value", (o1, o2) -> (o1 == null) == (o2 == null)) + ); + private Network network; @@ -294,10 +297,8 @@ List dynamicTestsBuildSpecificVoltageLimits() { final VoltageInitRunContext context = new VoltageInitRunContext(NETWORK_UUID, VARIANT_ID_1, null, REPORT_UUID, null, "", "", voltageInitParameters.getId()); final OpenReacParameters openReacParameters = voltageInitParametersService.buildOpenReacParameters(context, network); /*TODO*/System.out.println(parametersRepository.findAll().stream().map(ToStringBuilder::reflectionToString).collect(Collectors.joining())); - ReporterModel reporter = new ReporterModel("test", "test"); - VoltageInitWorkerService.addRestrictedVoltageLevelReport(context.getVoltageLevelsIdsRestricted(), reporter); - /*TODO*/System.out.println(mapper.writeValueAsString(reporter)); - JSONAssert.assertEquals("build parameters logs", TestUtils.resourceToString(reportFilename), mapper.writeValueAsString(reporter), false); + /*TODO*/System.out.println(mapper.writeValueAsString(context.getRootReporter())); + JSONAssert.assertEquals("build parameters logs", TestUtils.resourceToString(reportFilename), mapper.writeValueAsString(context.getRootReporter()), reporterComparator); return assertThat(openReacParameters.getSpecificVoltageLimits()).as("SpecificVoltageLimits"); }; final VoltageLimitEntity voltageLimit = new VoltageLimitEntity(UUID.randomUUID(), 5., 10., 0, VoltageLimitParameterType.DEFAULT, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); @@ -345,16 +346,4 @@ List dynamicTestsBuildSpecificVoltageLimits() { .containsOnlyOnce(new VoltageLimitOverride("VLHV1", VoltageLimitType.LOW_VOLTAGE_LIMIT, false, 0.0))) ); } - - @Test - void testAddRestrictedVoltageLevelReport() { - Map restrictedVoltageLevel = Map.of("vl", 10.0); - ReporterModel reporter = new ReporterModel("test", "test"); - VoltageInitWorkerService.addRestrictedVoltageLevelReport(restrictedVoltageLevel, reporter); - Reporter expected = new ReporterModel("test", "test"); - expected.report("restrictedVoltageLevels", - "The modifications to the low limits for certain voltage levels have been restricted to avoid negative voltage limits: vl=10.0", - Map.of(Report.REPORT_SEVERITY_KEY, TypedValue.WARN_SEVERITY)); - assertThat(reporter).usingRecursiveComparison().isEqualTo(expected); - } } diff --git a/src/test/resources/report_case_relative_false.json b/src/test/resources/report_case_relative_false.json index 39cfa4d0..4f640fb4 100644 --- a/src/test/resources/report_case_relative_false.json +++ b/src/test/resources/report_case_relative_false.json @@ -1,23 +1,38 @@ { "version": "1.0", "reportTree": { - "taskKey": "test", - "reports": [ + "taskKey": "VoltageInit", + "subReporters": [ { - "reportKey": "restrictedVoltageLevels", - "values": { - "reportSeverity": { - "value": "WARN", - "type": "SEVERITY" + "taskKey": "OpenReactParameters", + "taskValues": { + "parameters_id": { + "value": "11111111-1111-1111-1111-111111111111", + "type": "ID" } - } + }, + "reports": [ + { + "reportKey": "restrictedVoltageLevels", + "values": { + "reportSeverity": { + "value": "WARN", + "type": "SEVERITY" + }, + "joinedVoltageLevelsIds": { + "value": "VLHV2=-10.0, VLHV1=0.0, VLGEN=-10.0, VLLOAD=0.0" + } + } + } + ] } ] }, "dics": { "default": { - "restrictedVoltageLevels": "The modifications to the low limits for certain voltage levels have been restricted to avoid negative voltage limits: VLHV2=-10.0, VLHV1=0.0, VLGEN=-10.0, VLLOAD=0.0", - "test": "test" + "restrictedVoltageLevels": "The modifications to the low limits for certain voltage levels have been restricted to avoid negative voltage limits: ${joinedVoltageLevelsIds}", + "VoltageInit": "VoltageInit", + "OpenReactParameters": "OpenReact parameters" } } } diff --git a/src/test/resources/report_case_relative_true.json b/src/test/resources/report_case_relative_true.json index 1975b5ed..4039bed2 100644 --- a/src/test/resources/report_case_relative_true.json +++ b/src/test/resources/report_case_relative_true.json @@ -1,23 +1,38 @@ { "version": "1.0", "reportTree": { - "taskKey": "test", - "reports": [ + "taskKey": "VoltageInit", + "subReporters": [ { - "reportKey": "restrictedVoltageLevels", - "values": { - "reportSeverity": { - "value": "WARN", - "type": "SEVERITY" + "taskKey": "OpenReactParameters", + "taskValues": { + "parameters_id": { + "value": "11111111-1111-1111-1111-111111111111", + "type": "ID" } - } + }, + "reports": [ + { + "reportKey": "restrictedVoltageLevels", + "values": { + "reportSeverity": { + "value": "WARN", + "type": "SEVERITY" + }, + "joinedVoltageLevelsIds": { + "value": "VLHV2=-10.0, VLGEN=-10.0" + } + } + } + ] } ] }, "dics": { "default": { - "restrictedVoltageLevels": "The modifications to the low limits for certain voltage levels have been restricted to avoid negative voltage limits: VLHV2=-10.0, VLGEN=-10.0", - "test": "test" + "restrictedVoltageLevels": "The modifications to the low limits for certain voltage levels have been restricted to avoid negative voltage limits: ${joinedVoltageLevelsIds}", + "VoltageInit": "VoltageInit", + "OpenReactParameters": "OpenReact parameters" } } } diff --git a/src/test/resources/report_empty.json b/src/test/resources/report_empty.json index 599fb21f..b6d3ec20 100644 --- a/src/test/resources/report_empty.json +++ b/src/test/resources/report_empty.json @@ -1,7 +1,23 @@ { "version": "1.0", - "reportTree": { "taskKey": "test" }, + "reportTree": { + "taskKey": "VoltageInit", + "subReporters": [ + { + "taskKey": "OpenReactParameters", + "taskValues": { + "parameters_id": { + "value": "11111111-1111-1111-1111-111111111111", + "type": "ID" + } + } + } + ] + }, "dics": { - "default": { "test": "test" } + "default": { + "VoltageInit": "VoltageInit", + "OpenReactParameters": "OpenReact parameters" + } } } From 8fb02eccacb5413f6c8073f880cc57f333b49504 Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Fri, 22 Mar 2024 08:48:33 +0100 Subject: [PATCH 13/53] Added new logs --- .../VoltageInitParametersService.java | 33 ++++ .../server/VoltageInitParametersTest.java | 8 +- .../resources/report_case_relative_false.json | 38 ---- .../resources/report_case_relative_true.json | 38 ---- src/test/resources/report_empty.json | 23 --- .../reporter_buildOpenReacParameters.json | 139 ++++++++++++++ ...dOpenReacParameters_caseRelativeFalse.json | 181 ++++++++++++++++++ ...ldOpenReacParameters_caseRelativeTrue.json | 152 +++++++++++++++ ...ReacParameters_withLimitModifications.json | 168 ++++++++++++++++ 9 files changed, 677 insertions(+), 103 deletions(-) delete mode 100644 src/test/resources/report_case_relative_false.json delete mode 100644 src/test/resources/report_case_relative_true.json delete mode 100644 src/test/resources/report_empty.json create mode 100644 src/test/resources/reporter_buildOpenReacParameters.json create mode 100644 src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json create mode 100644 src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json create mode 100644 src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index 4a84b7d2..13500a4f 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -212,6 +212,39 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, .withSeverity(TypedValue.TRACE_SEVERITY) .build())); + long nbMissingVoltageLimits = 0L; + long nbVoltageLimitModifications = 0L; + parameters.getSpecificVoltageLimits() + .stream() + .collect(Collectors.groupingBy(VoltageLimitOverride::getVoltageLevelId)) + .forEach((id, voltageLimits) -> { + final Map newLimits = voltageLimits.stream() + .collect(Collectors.groupingBy(VoltageLimitOverride::getVoltageLimitType, Collectors.summingDouble(VoltageLimitOverride::getLimit))); + final VoltageLevel voltageLevel = network.getVoltageLevel(id); + reporter.report(Report.builder() + .withKey("voltageLimitModified") + .withDefaultMessage("On or two voltage limits of voltage level ${voltageLevelId} have been replaced and/or modified low voltage limit = ${newLowVoltageLimit}kV, high voltage limit = ${newHighVoltageLimit}kV (initial values: low voltage limit = ${initialLowVoltageLimit}kV, high voltage limit = ${initialHighVoltage}kV).") + .withTypedValue("voltageLevelId", voltageLevel.getId(), TypedValue.VOLTAGE_LEVEL) + .withTypedValue("newLowVoltageLimit", newLimits.getOrDefault(VoltageLimitType.LOW_VOLTAGE_LIMIT, voltageLevel.getLowVoltageLimit()), TypedValue.VOLTAGE) + .withTypedValue("newHighVoltageLimit", newLimits.getOrDefault(VoltageLimitType.HIGH_VOLTAGE_LIMIT, voltageLevel.getHighVoltageLimit()), TypedValue.VOLTAGE) + .withTypedValue("initialLowVoltageLimit", voltageLevel.getLowVoltageLimit(), TypedValue.VOLTAGE) + .withTypedValue("initialHighVoltage", voltageLevel.getHighVoltageLimit(), TypedValue.VOLTAGE) + .withSeverity(TypedValue.TRACE_SEVERITY) + .build()); + }); + reporter.report(Report.builder() + .withKey("missingVoltageLimits") + .withDefaultMessage("Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.") + .withValue("nbMissingVoltageLimits", nbMissingVoltageLimits) + .withSeverity(TypedValue.INFO_SEVERITY) + .build()); + reporter.report(Report.builder() + .withKey("voltageLimitModifications") + .withDefaultMessage("Voltage limits of ${nbVoltageLimitModifications} voltage levels have been modified according to user input.") + .withValue("nbVoltageLimitModifications", nbVoltageLimitModifications) + .withSeverity(TypedValue.INFO_SEVERITY) + .build()); + //The optimizer will attach reactive slack variables to all buses parameters.setReactiveSlackBusesMode(ReactiveSlackBusesMode.ALL); diff --git a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java index a4d102e1..3feeaa4c 100644 --- a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java +++ b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java @@ -307,7 +307,7 @@ List dynamicTestsBuildSpecificVoltageLimits() { final VoltageLimitEntity voltageLimit4 = new VoltageLimitEntity(UUID.randomUUID(), -20.0, 10.0, 0, VoltageLimitParameterType.MODIFICATION, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); final VoltageLimitEntity voltageLimit5 = new VoltageLimitEntity(UUID.randomUUID(), 10.0, 10.0, 0, VoltageLimitParameterType.DEFAULT, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); return List.of( - DynamicTest.dynamicTest("No voltage limit modification", () -> initTestEnv.apply(List.of(voltageLimit, voltageLimit2), "report_empty.json") + DynamicTest.dynamicTest("No voltage limit modification", () -> initTestEnv.apply(List.of(voltageLimit, voltageLimit2), "reporter_buildOpenReacParameters.json") .hasSize(4) //No override should be relative since there is no voltage limit modification .noneMatch(VoltageLimitOverride::isRelative) @@ -320,7 +320,7 @@ List dynamicTestsBuildSpecificVoltageLimits() { assertVoltageLimitOverride("VLLOAD", VoltageLimitType.HIGH_VOLTAGE_LIMIT, 88.) )), //We now add limit modifications in additions to defaults settings - DynamicTest.dynamicTest("With voltage limit modifications", () -> initTestEnv.apply(List.of(voltageLimit, voltageLimit2, voltageLimit3), "report_empty.json") + DynamicTest.dynamicTest("With voltage limit modifications", () -> initTestEnv.apply(List.of(voltageLimit, voltageLimit2, voltageLimit3), "reporter_buildOpenReacParameters_withLimitModifications.json") //Limits that weren't impacted by default settings are now impacted by modification settings .hasSize(8) //There should (not?) be relative overrides since voltage limit modification are applied @@ -333,13 +333,13 @@ List dynamicTestsBuildSpecificVoltageLimits() { .satisfiesOnlyOnce(assertVoltageLimitOverride("VLLOAD", VoltageLimitType.HIGH_VOLTAGE_LIMIT, 86.))), //note: VoltageLimitOverride implement equals() correctly, so we can use it // We need to check for the case of relative = true with the modification less than 0 => the new low voltage limit = low voltage limit * -1 - DynamicTest.dynamicTest("Case relative true overrides", () -> initTestEnv.apply(List.of(voltageLimit4), "report_case_relative_true.json") + DynamicTest.dynamicTest("Case relative true overrides", () -> initTestEnv.apply(List.of(voltageLimit4), "reporter_buildOpenReacParameters_caseRelativeTrue.json") .hasSize(4) // isRelative: There should have relative true overrides since voltage limit modification are applied for VLGEN // getLimit: The low voltage limit must be impacted by the modification of the value .containsOnlyOnce(new VoltageLimitOverride("VLGEN", VoltageLimitType.LOW_VOLTAGE_LIMIT, true, -10.0))), // We need to check for the case of relative = false with the modification less than 0 => the new low voltage limit = 0 - DynamicTest.dynamicTest("Case relative false overrides", () -> initTestEnv.apply(List.of(voltageLimit4, voltageLimit5), "report_case_relative_false.json") + DynamicTest.dynamicTest("Case relative false overrides", () -> initTestEnv.apply(List.of(voltageLimit4, voltageLimit5), "reporter_buildOpenReacParameters_caseRelativeFalse.json") .hasSize(8) // isRelative: There should have relative false overrides since voltage limit modification are applied for VLHV1 // getLimit: The low voltage limit must be impacted by the modification of the value diff --git a/src/test/resources/report_case_relative_false.json b/src/test/resources/report_case_relative_false.json deleted file mode 100644 index 4f640fb4..00000000 --- a/src/test/resources/report_case_relative_false.json +++ /dev/null @@ -1,38 +0,0 @@ -{ - "version": "1.0", - "reportTree": { - "taskKey": "VoltageInit", - "subReporters": [ - { - "taskKey": "OpenReactParameters", - "taskValues": { - "parameters_id": { - "value": "11111111-1111-1111-1111-111111111111", - "type": "ID" - } - }, - "reports": [ - { - "reportKey": "restrictedVoltageLevels", - "values": { - "reportSeverity": { - "value": "WARN", - "type": "SEVERITY" - }, - "joinedVoltageLevelsIds": { - "value": "VLHV2=-10.0, VLHV1=0.0, VLGEN=-10.0, VLLOAD=0.0" - } - } - } - ] - } - ] - }, - "dics": { - "default": { - "restrictedVoltageLevels": "The modifications to the low limits for certain voltage levels have been restricted to avoid negative voltage limits: ${joinedVoltageLevelsIds}", - "VoltageInit": "VoltageInit", - "OpenReactParameters": "OpenReact parameters" - } - } -} diff --git a/src/test/resources/report_case_relative_true.json b/src/test/resources/report_case_relative_true.json deleted file mode 100644 index 4039bed2..00000000 --- a/src/test/resources/report_case_relative_true.json +++ /dev/null @@ -1,38 +0,0 @@ -{ - "version": "1.0", - "reportTree": { - "taskKey": "VoltageInit", - "subReporters": [ - { - "taskKey": "OpenReactParameters", - "taskValues": { - "parameters_id": { - "value": "11111111-1111-1111-1111-111111111111", - "type": "ID" - } - }, - "reports": [ - { - "reportKey": "restrictedVoltageLevels", - "values": { - "reportSeverity": { - "value": "WARN", - "type": "SEVERITY" - }, - "joinedVoltageLevelsIds": { - "value": "VLHV2=-10.0, VLGEN=-10.0" - } - } - } - ] - } - ] - }, - "dics": { - "default": { - "restrictedVoltageLevels": "The modifications to the low limits for certain voltage levels have been restricted to avoid negative voltage limits: ${joinedVoltageLevelsIds}", - "VoltageInit": "VoltageInit", - "OpenReactParameters": "OpenReact parameters" - } - } -} diff --git a/src/test/resources/report_empty.json b/src/test/resources/report_empty.json deleted file mode 100644 index b6d3ec20..00000000 --- a/src/test/resources/report_empty.json +++ /dev/null @@ -1,23 +0,0 @@ -{ - "version": "1.0", - "reportTree": { - "taskKey": "VoltageInit", - "subReporters": [ - { - "taskKey": "OpenReactParameters", - "taskValues": { - "parameters_id": { - "value": "11111111-1111-1111-1111-111111111111", - "type": "ID" - } - } - } - ] - }, - "dics": { - "default": { - "VoltageInit": "VoltageInit", - "OpenReactParameters": "OpenReact parameters" - } - } -} diff --git a/src/test/resources/reporter_buildOpenReacParameters.json b/src/test/resources/reporter_buildOpenReacParameters.json new file mode 100644 index 00000000..d40cf868 --- /dev/null +++ b/src/test/resources/reporter_buildOpenReacParameters.json @@ -0,0 +1,139 @@ +{ + "version": "1.0", + "reportTree": { + "taskKey": "VoltageInit", + "subReporters": [ + { + "taskKey": "OpenReactParameters", + "taskValues": { + "parameters_id": { + "value": "11111111-1111-1111-1111-111111111111", + "type": "ID" + } + }, + "reports": [ + { + "reportKey": "voltageLimitModified", + "values": { + "initialLowVoltageLimit": { + "value": 10.0, + "type": "VOLTAGE" + }, + "voltageLevelId": { + "value": "VLHV2", + "type": "VOLTAGE_LEVEL" + }, + "reportSeverity": { + "value": "TRACE", + "type": "SEVERITY" + }, + "newHighVoltageLimit": { + "value": 10.0, + "type": "VOLTAGE" + }, + "initialHighVoltage": { + "value": "NaN", + "type": "VOLTAGE" + }, + "newLowVoltageLimit": { + "value": 10.0, + "type": "VOLTAGE" + } + } + }, + { + "reportKey": "voltageLimitModified", + "values": { + "initialLowVoltageLimit": { + "value": "NaN", + "type": "VOLTAGE" + }, + "voltageLevelId": { + "value": "VLHV1", + "type": "VOLTAGE_LEVEL" + }, + "reportSeverity": { + "value": "TRACE", + "type": "SEVERITY" + }, + "newHighVoltageLimit": { + "value": 20.0, + "type": "VOLTAGE" + }, + "initialHighVoltage": { + "value": 20.0, + "type": "VOLTAGE" + }, + "newLowVoltageLimit": { + "value": 5.0, + "type": "VOLTAGE" + } + } + }, + { + "reportKey": "voltageLimitModified", + "values": { + "initialLowVoltageLimit": { + "value": "NaN", + "type": "VOLTAGE" + }, + "voltageLevelId": { + "value": "VLLOAD", + "type": "VOLTAGE_LEVEL" + }, + "reportSeverity": { + "value": "TRACE", + "type": "SEVERITY" + }, + "newHighVoltageLimit": { + "value": 88.0, + "type": "VOLTAGE" + }, + "initialHighVoltage": { + "value": "NaN", + "type": "VOLTAGE" + }, + "newLowVoltageLimit": { + "value": 44.0, + "type": "VOLTAGE" + } + } + }, + { + "reportKey": "missingVoltageLimits", + "values": { + "nbMissingVoltageLimits": { + "value": 0 + }, + "reportSeverity": { + "value": "INFO", + "type": "SEVERITY" + } + } + }, + { + "reportKey": "voltageLimitModifications", + "values": { + "reportSeverity": { + "value": "INFO", + "type": "SEVERITY" + }, + "nbVoltageLimitModifications": { + "value": 0 + } + } + } + ] + } + ] + }, + "dics": { + "default": { + "voltageLimitModifications": "Voltage limits of ${nbVoltageLimitModifications} voltage levels have been modified according to user input.", + "VoltageInit": "VoltageInit", + "OpenReactParameters": "OpenReact parameters", + "missingVoltageLimits": "Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.", + "voltageLimitModified": "On or two voltage limits of voltage level ${voltageLevelId} have been replaced and/or modified low voltage limit = ${newLowVoltageLimit}kV, high voltage limit = ${newHighVoltageLimit}kV (initial values: low voltage limit = ${initialLowVoltageLimit}kV, high voltage limit = ${initialHighVoltage}kV)." + } + } +} diff --git a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json new file mode 100644 index 00000000..2f105665 --- /dev/null +++ b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json @@ -0,0 +1,181 @@ +{ + "version": "1.0", + "reportTree": { + "taskKey": "VoltageInit", + "subReporters": [ + { + "taskKey": "OpenReactParameters", + "taskValues": { + "parameters_id": { + "value": "11111111-1111-1111-1111-111111111111", + "type": "ID" + } + }, + "reports": [ + { + "reportKey": "restrictedVoltageLevels", + "values": { + "reportSeverity": { + "value": "WARN", + "type": "SEVERITY" + }, + "joinedVoltageLevelsIds": { + "value": "VLHV2=-10.0, VLHV1=0.0, VLGEN=-10.0, VLLOAD=0.0" + } + } + }, + { + "reportKey": "voltageLimitModified", + "values": { + "initialLowVoltageLimit": { + "value": 10.0, + "type": "VOLTAGE" + }, + "voltageLevelId": { + "value": "VLHV2", + "type": "VOLTAGE_LEVEL" + }, + "reportSeverity": { + "value": "TRACE", + "type": "SEVERITY" + }, + "newHighVoltageLimit": { + "value": 20.0, + "type": "VOLTAGE" + }, + "initialHighVoltage": { + "value": "NaN", + "type": "VOLTAGE" + }, + "newLowVoltageLimit": { + "value": -10.0, + "type": "VOLTAGE" + } + } + }, + { + "reportKey": "voltageLimitModified", + "values": { + "initialLowVoltageLimit": { + "value": "NaN", + "type": "VOLTAGE" + }, + "voltageLevelId": { + "value": "VLHV1", + "type": "VOLTAGE_LEVEL" + }, + "reportSeverity": { + "value": "TRACE", + "type": "SEVERITY" + }, + "newHighVoltageLimit": { + "value": 10.0, + "type": "VOLTAGE" + }, + "initialHighVoltage": { + "value": 20.0, + "type": "VOLTAGE" + }, + "newLowVoltageLimit": { + "value": 0.0, + "type": "VOLTAGE" + } + } + }, + { + "reportKey": "voltageLimitModified", + "values": { + "initialLowVoltageLimit": { + "value": 10.0, + "type": "VOLTAGE" + }, + "voltageLevelId": { + "value": "VLGEN", + "type": "VOLTAGE_LEVEL" + }, + "reportSeverity": { + "value": "TRACE", + "type": "SEVERITY" + }, + "newHighVoltageLimit": { + "value": 10.0, + "type": "VOLTAGE" + }, + "initialHighVoltage": { + "value": 20.0, + "type": "VOLTAGE" + }, + "newLowVoltageLimit": { + "value": -10.0, + "type": "VOLTAGE" + } + } + }, + { + "reportKey": "voltageLimitModified", + "values": { + "initialLowVoltageLimit": { + "value": "NaN", + "type": "VOLTAGE" + }, + "voltageLevelId": { + "value": "VLLOAD", + "type": "VOLTAGE_LEVEL" + }, + "reportSeverity": { + "value": "TRACE", + "type": "SEVERITY" + }, + "newHighVoltageLimit": { + "value": 20.0, + "type": "VOLTAGE" + }, + "initialHighVoltage": { + "value": "NaN", + "type": "VOLTAGE" + }, + "newLowVoltageLimit": { + "value": 0.0, + "type": "VOLTAGE" + } + } + }, + { + "reportKey": "missingVoltageLimits", + "values": { + "nbMissingVoltageLimits": { + "value": 0 + }, + "reportSeverity": { + "value": "INFO", + "type": "SEVERITY" + } + } + }, + { + "reportKey": "voltageLimitModifications", + "values": { + "reportSeverity": { + "value": "INFO", + "type": "SEVERITY" + }, + "nbVoltageLimitModifications": { + "value": 0 + } + } + } + ] + } + ] + }, + "dics": { + "default": { + "restrictedVoltageLevels": "The modifications to the low limits for certain voltage levels have been restricted to avoid negative voltage limits: ${joinedVoltageLevelsIds}", + "voltageLimitModifications": "Voltage limits of ${nbVoltageLimitModifications} voltage levels have been modified according to user input.", + "VoltageInit": "VoltageInit", + "OpenReactParameters": "OpenReact parameters", + "missingVoltageLimits": "Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.", + "voltageLimitModified": "On or two voltage limits of voltage level ${voltageLevelId} have been replaced and/or modified low voltage limit = ${newLowVoltageLimit}kV, high voltage limit = ${newHighVoltageLimit}kV (initial values: low voltage limit = ${initialLowVoltageLimit}kV, high voltage limit = ${initialHighVoltage}kV)." + } + } +} diff --git a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json new file mode 100644 index 00000000..a9413d21 --- /dev/null +++ b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json @@ -0,0 +1,152 @@ +{ + "version": "1.0", + "reportTree": { + "taskKey": "VoltageInit", + "subReporters": [ + { + "taskKey": "OpenReactParameters", + "taskValues": { + "parameters_id": { + "value": "11111111-1111-1111-1111-111111111111", + "type": "ID" + } + }, + "reports": [ + { + "reportKey": "restrictedVoltageLevels", + "values": { + "reportSeverity": { + "value": "WARN", + "type": "SEVERITY" + }, + "joinedVoltageLevelsIds": { + "value": "VLHV2=-10.0, VLGEN=-10.0" + } + } + }, + { + "reportKey": "voltageLimitModified", + "values": { + "initialLowVoltageLimit": { + "value": 10.0, + "type": "VOLTAGE" + }, + "voltageLevelId": { + "value": "VLHV2", + "type": "VOLTAGE_LEVEL" + }, + "reportSeverity": { + "value": "TRACE", + "type": "SEVERITY" + }, + "newHighVoltageLimit": { + "value": "NaN", + "type": "VOLTAGE" + }, + "initialHighVoltage": { + "value": "NaN", + "type": "VOLTAGE" + }, + "newLowVoltageLimit": { + "value": -10.0, + "type": "VOLTAGE" + } + } + }, + { + "reportKey": "voltageLimitModified", + "values": { + "initialLowVoltageLimit": { + "value": "NaN", + "type": "VOLTAGE" + }, + "voltageLevelId": { + "value": "VLHV1", + "type": "VOLTAGE_LEVEL" + }, + "reportSeverity": { + "value": "TRACE", + "type": "SEVERITY" + }, + "newHighVoltageLimit": { + "value": 10.0, + "type": "VOLTAGE" + }, + "initialHighVoltage": { + "value": 20.0, + "type": "VOLTAGE" + }, + "newLowVoltageLimit": { + "value": "NaN", + "type": "VOLTAGE" + } + } + }, + { + "reportKey": "voltageLimitModified", + "values": { + "initialLowVoltageLimit": { + "value": 10.0, + "type": "VOLTAGE" + }, + "voltageLevelId": { + "value": "VLGEN", + "type": "VOLTAGE_LEVEL" + }, + "reportSeverity": { + "value": "TRACE", + "type": "SEVERITY" + }, + "newHighVoltageLimit": { + "value": 10.0, + "type": "VOLTAGE" + }, + "initialHighVoltage": { + "value": 20.0, + "type": "VOLTAGE" + }, + "newLowVoltageLimit": { + "value": -10.0, + "type": "VOLTAGE" + } + } + }, + { + "reportKey": "missingVoltageLimits", + "values": { + "nbMissingVoltageLimits": { + "value": 0 + }, + "reportSeverity": { + "value": "INFO", + "type": "SEVERITY" + } + } + }, + { + "reportKey": "voltageLimitModifications", + "values": { + "reportSeverity": { + "value": "INFO", + "type": "SEVERITY" + }, + "nbVoltageLimitModifications": { + "value": 0 + } + } + } + ] + } + ] + }, + "dics": { + "default": { + "restrictedVoltageLevels": "The modifications to the low limits for certain voltage levels have been restricted to avoid negative voltage limits: ${joinedVoltageLevelsIds}", + "voltageLimitModifications": "Voltage limits of ${nbVoltageLimitModifications} voltage levels have been modified according to user input.", + "VoltageInit": "VoltageInit", + "OpenReactParameters": "OpenReact parameters", + "missingVoltageLimits": "Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.", + "voltageLimitModified": "On or two voltage limits of voltage level ${voltageLevelId} have been replaced and/or modified low voltage limit = ${newLowVoltageLimit}kV, high voltage limit = ${newHighVoltageLimit}kV (initial values: low voltage limit = ${initialLowVoltageLimit}kV, high voltage limit = ${initialHighVoltage}kV)." + } + } +} diff --git a/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json b/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json new file mode 100644 index 00000000..363ef76e --- /dev/null +++ b/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json @@ -0,0 +1,168 @@ +{ + "version": "1.0", + "reportTree": { + "taskKey": "VoltageInit", + "subReporters": [ + { + "taskKey": "OpenReactParameters", + "taskValues": { + "parameters_id": { + "value": "11111111-1111-1111-1111-111111111111", + "type": "ID" + } + }, + "reports": [ + { + "reportKey": "voltageLimitModified", + "values": { + "initialLowVoltageLimit": { + "value": 10.0, + "type": "VOLTAGE" + }, + "voltageLevelId": { + "value": "VLHV2", + "type": "VOLTAGE_LEVEL" + }, + "reportSeverity": { + "value": "TRACE", + "type": "SEVERITY" + }, + "newHighVoltageLimit": { + "value": 8.0, + "type": "VOLTAGE" + }, + "initialHighVoltage": { + "value": "NaN", + "type": "VOLTAGE" + }, + "newLowVoltageLimit": { + "value": -1.0, + "type": "VOLTAGE" + } + } + }, + { + "reportKey": "voltageLimitModified", + "values": { + "initialLowVoltageLimit": { + "value": "NaN", + "type": "VOLTAGE" + }, + "voltageLevelId": { + "value": "VLHV1", + "type": "VOLTAGE_LEVEL" + }, + "reportSeverity": { + "value": "TRACE", + "type": "SEVERITY" + }, + "newHighVoltageLimit": { + "value": -2.0, + "type": "VOLTAGE" + }, + "initialHighVoltage": { + "value": 20.0, + "type": "VOLTAGE" + }, + "newLowVoltageLimit": { + "value": 4.0, + "type": "VOLTAGE" + } + } + }, + { + "reportKey": "voltageLimitModified", + "values": { + "initialLowVoltageLimit": { + "value": 10.0, + "type": "VOLTAGE" + }, + "voltageLevelId": { + "value": "VLGEN", + "type": "VOLTAGE_LEVEL" + }, + "reportSeverity": { + "value": "TRACE", + "type": "SEVERITY" + }, + "newHighVoltageLimit": { + "value": -2.0, + "type": "VOLTAGE" + }, + "initialHighVoltage": { + "value": 20.0, + "type": "VOLTAGE" + }, + "newLowVoltageLimit": { + "value": -1.0, + "type": "VOLTAGE" + } + } + }, + { + "reportKey": "voltageLimitModified", + "values": { + "initialLowVoltageLimit": { + "value": "NaN", + "type": "VOLTAGE" + }, + "voltageLevelId": { + "value": "VLLOAD", + "type": "VOLTAGE_LEVEL" + }, + "reportSeverity": { + "value": "TRACE", + "type": "SEVERITY" + }, + "newHighVoltageLimit": { + "value": 86.0, + "type": "VOLTAGE" + }, + "initialHighVoltage": { + "value": "NaN", + "type": "VOLTAGE" + }, + "newLowVoltageLimit": { + "value": 43.0, + "type": "VOLTAGE" + } + } + }, + { + "reportKey": "missingVoltageLimits", + "values": { + "nbMissingVoltageLimits": { + "value": 0 + }, + "reportSeverity": { + "value": "INFO", + "type": "SEVERITY" + } + } + }, + { + "reportKey": "voltageLimitModifications", + "values": { + "reportSeverity": { + "value": "INFO", + "type": "SEVERITY" + }, + "nbVoltageLimitModifications": { + "value": 0 + } + } + } + ] + } + ] + }, + "dics": { + "default": { + "voltageLimitModifications": "Voltage limits of ${nbVoltageLimitModifications} voltage levels have been modified according to user input.", + "VoltageInit": "VoltageInit", + "OpenReactParameters": "OpenReact parameters", + "missingVoltageLimits": "Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.", + "voltageLimitModified": "On or two voltage limits of voltage level ${voltageLevelId} have been replaced and/or modified low voltage limit = ${newLowVoltageLimit}kV, high voltage limit = ${newHighVoltageLimit}kV (initial values: low voltage limit = ${initialLowVoltageLimit}kV, high voltage limit = ${initialHighVoltage}kV)." + } + } +} From 9b3dbc3541994c16d1f25dee0678a21977f646ee Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Fri, 22 Mar 2024 10:34:02 +0100 Subject: [PATCH 14/53] fix checkstyle --- .../voltageinit/server/VoltageInitParametersTest.java | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java index 3feeaa4c..72237d9e 100644 --- a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java +++ b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java @@ -90,12 +90,11 @@ class VoltageInitParametersTest { private static final String FILTER_2 = "FILTER_2"; private static final UUID REPORT_UUID = UUID.fromString("00000000-0000-0000-0000-000000000000"); - private static final JSONComparator reporterComparator = new CustomComparator(JSONCompareMode.STRICT, + private static final JSONComparator REPORTER_COMPARATOR = new CustomComparator(JSONCompareMode.STRICT, // ignore field having uuid changing each run new Customization("reportTree.subReporters[*].taskValues.parameters_id.value", (o1, o2) -> (o1 == null) == (o2 == null)) ); - private Network network; @Autowired @@ -159,7 +158,7 @@ void testRead() throws Exception { MvcResult mvcResult = mockMvc.perform(get(URI_PARAMETERS_GET_PUT + parametersUuid)) .andExpect(status().isOk()).andReturn(); String resultAsString = mvcResult.getResponse().getContentAsString(); - assertThat(mapper.readValue(resultAsString, new TypeReference() {})) + assertThat(mapper.readValue(resultAsString, new TypeReference() { })) .as("received parameters") .recursivelyEquals(parametersToRead); } @@ -189,7 +188,7 @@ void testGetAll() throws Exception { MvcResult mvcResult = mockMvc.perform(get(URI_PARAMETERS_BASE)) .andExpect(status().isOk()).andReturn(); String resultAsString = mvcResult.getResponse().getContentAsString(); - assertThat(mapper.readValue(resultAsString, new TypeReference>() {})) + assertThat(mapper.readValue(resultAsString, new TypeReference>() { })) .as("received parameters") .hasSize(2); } @@ -298,7 +297,7 @@ List dynamicTestsBuildSpecificVoltageLimits() { final OpenReacParameters openReacParameters = voltageInitParametersService.buildOpenReacParameters(context, network); /*TODO*/System.out.println(parametersRepository.findAll().stream().map(ToStringBuilder::reflectionToString).collect(Collectors.joining())); /*TODO*/System.out.println(mapper.writeValueAsString(context.getRootReporter())); - JSONAssert.assertEquals("build parameters logs", TestUtils.resourceToString(reportFilename), mapper.writeValueAsString(context.getRootReporter()), reporterComparator); + JSONAssert.assertEquals("build parameters logs", TestUtils.resourceToString(reportFilename), mapper.writeValueAsString(context.getRootReporter()), REPORTER_COMPARATOR); return assertThat(openReacParameters.getSpecificVoltageLimits()).as("SpecificVoltageLimits"); }; final VoltageLimitEntity voltageLimit = new VoltageLimitEntity(UUID.randomUUID(), 5., 10., 0, VoltageLimitParameterType.DEFAULT, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); From cd420644c80bf3fda5f216f9ac4d12b3aca51f9d Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Fri, 22 Mar 2024 10:08:13 +0100 Subject: [PATCH 15/53] Add missing lombok config generated code not marked as it for coverage --- .mvn/lombok-config-copy.marker | 0 lombok.config | 1 + 2 files changed, 1 insertion(+) create mode 100644 .mvn/lombok-config-copy.marker create mode 100644 lombok.config diff --git a/.mvn/lombok-config-copy.marker b/.mvn/lombok-config-copy.marker new file mode 100644 index 00000000..e69de29b diff --git a/lombok.config b/lombok.config new file mode 100644 index 00000000..4fa82504 --- /dev/null +++ b/lombok.config @@ -0,0 +1 @@ +import target/configs/powsybl-build-tools.jar!powsybl-build-tools/lombok.config From fc7e221b9344db04306fa176df3bf74c251fc222 Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Fri, 22 Mar 2024 12:26:36 +0100 Subject: [PATCH 16/53] clean PR --- pom.xml | 5 + .../service/VoltageInitResultContext.java | 26 ++--- .../server/service/VoltageInitService.java | 9 +- .../VoltageInitParametersService.java | 88 ++++++--------- .../server/SupervisionControllerTest.java | 15 ++- .../server/VoltageInitControllerTest.java | 80 +++++++------ .../server/VoltageInitParametersTest.java | 105 +++++++++++------- .../service/ReportServiceTest.java | 24 ++-- 8 files changed, 196 insertions(+), 156 deletions(-) diff --git a/pom.xml b/pom.xml index 91cc6c23..3d7db5ea 100644 --- a/pom.xml +++ b/pom.xml @@ -199,6 +199,11 @@ assertj-guava test + + org.junit.vintage + junit-vintage-engine + test + org.mockito mockito-core diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitResultContext.java b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitResultContext.java index cb0cbcc3..f072c673 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitResultContext.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitResultContext.java @@ -45,12 +45,11 @@ public VoltageInitResultContext(UUID resultUuid, VoltageInitRunContext runContex } private static String getNonNullHeader(MessageHeaders headers, String name) { - final String header = headers.get(name, String.class); + String header = (String) headers.get(name); if (header == null) { throw new PowsyblException("Header '" + name + "' not found"); - } else { - return header; } + return header; } public static VoltageInitResultContext fromMessage(Message message) { @@ -58,16 +57,17 @@ public static VoltageInitResultContext fromMessage(Message message) { MessageHeaders headers = message.getHeaders(); UUID resultUuid = UUID.fromString(getNonNullHeader(headers, "resultUuid")); UUID networkUuid = UUID.fromString(getNonNullHeader(headers, "networkUuid")); - String variantId = headers.get(VARIANT_ID_HEADER, String.class); - String receiver = headers.get(HEADER_RECEIVER, String.class); - String userId = headers.get(HEADER_USER_ID, String.class); - @SuppressWarnings("unchecked") - Map voltageLevelsIdsRestricted = headers.get(VOLTAGE_LEVELS_IDS_RESTRICTED, Map.class); - UUID parametersUuid = headers.containsKey(PARAMETERS_UUID_HEADER) ? UUID.fromString(headers.get(PARAMETERS_UUID_HEADER, String.class)) : null; - UUID reportUuid = headers.containsKey(REPORT_UUID_HEADER) ? UUID.fromString(headers.get(REPORT_UUID_HEADER, String.class)) : null; - String reporterId = headers.containsKey(REPORTER_ID_HEADER) ? headers.get(REPORTER_ID_HEADER, String.class) : null; - String reportType = headers.containsKey(REPORT_TYPE_HEADER) ? headers.get(REPORT_TYPE_HEADER, String.class) : null; - return new VoltageInitResultContext(resultUuid, new VoltageInitRunContext(networkUuid, variantId, receiver, reportUuid, reporterId, reportType, userId, parametersUuid, voltageLevelsIdsRestricted)); + String variantId = (String) headers.get(VARIANT_ID_HEADER); + String receiver = (String) headers.get(HEADER_RECEIVER); + String userId = (String) headers.get(HEADER_USER_ID); + Map voltageLevelsIdsRestricted = (Map) headers.get(VOLTAGE_LEVELS_IDS_RESTRICTED); + + UUID parametersUuid = headers.containsKey(PARAMETERS_UUID_HEADER) ? UUID.fromString((String) headers.get(PARAMETERS_UUID_HEADER)) : null; + 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; + VoltageInitRunContext runContext = new VoltageInitRunContext(networkUuid, variantId, receiver, reportUuid, reporterId, reportType, userId, parametersUuid, voltageLevelsIdsRestricted); + return new VoltageInitResultContext(resultUuid, runContext); } public Message toMessage() { diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitService.java b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitService.java index 74bddb7d..b0090f4a 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitService.java @@ -6,12 +6,15 @@ */ package org.gridsuite.voltageinit.server.service; +import com.powsybl.network.store.client.NetworkStoreService; + import org.gridsuite.voltageinit.server.dto.ReactiveSlack; import org.gridsuite.voltageinit.server.dto.VoltageInitResult; import org.gridsuite.voltageinit.server.dto.VoltageInitStatus; import org.gridsuite.voltageinit.server.entities.VoltageInitResultEntity; import org.gridsuite.voltageinit.server.repository.VoltageInitResultRepository; import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.ComponentScan; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; @@ -22,6 +25,7 @@ /** * @author Etienne Homer */ +@ComponentScan(basePackageClasses = {NetworkStoreService.class}) @Service public class VoltageInitService { @Autowired @@ -45,8 +49,9 @@ public VoltageInitService(NotificationService notificationService, } public UUID runAndSaveResult(UUID networkUuid, String variantId, String receiver, UUID reportUuid, String reporterId, String userId, String reportType, UUID parametersUuid) { - final VoltageInitRunContext runContext = new VoltageInitRunContext(networkUuid, variantId, receiver, reportUuid, reporterId, reportType, userId, parametersUuid); - final UUID resultUuid = uuidGeneratorService.generate(); + VoltageInitRunContext runContext = new VoltageInitRunContext(networkUuid, variantId, receiver, reportUuid, reporterId, reportType, userId, parametersUuid, new HashMap<>()); + Objects.requireNonNull(runContext); + var resultUuid = uuidGeneratorService.generate(); // update status to running status setStatus(List.of(resultUuid), VoltageInitStatus.RUNNING.name()); diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index 13500a4f..9f3b09a5 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -54,13 +54,13 @@ public UUID createParameters(VoltageInitParametersInfos parametersInfos) { } public Optional duplicateParameters(UUID sourceParametersId) { - return voltageInitParametersRepository.findById(sourceParametersId) - .map(VoltageInitParametersEntity::toVoltageInitParametersInfos) - .map(VoltageInitParametersEntity::new) - .map(entity -> { - voltageInitParametersRepository.save(entity); - return entity.getId(); - }); + Optional sourceVoltageInitParametersInfos = voltageInitParametersRepository.findById(sourceParametersId).map(VoltageInitParametersEntity::toVoltageInitParametersInfos); + if (sourceVoltageInitParametersInfos.isPresent()) { + VoltageInitParametersEntity entity = new VoltageInitParametersEntity(sourceVoltageInitParametersInfos.get()); + voltageInitParametersRepository.save(entity); + return Optional.of(entity.getId()); + } + return Optional.empty(); } public VoltageInitParametersInfos getParameters(UUID parametersUuid) { @@ -101,10 +101,8 @@ private static void fillSpecificVoltageLimits(List specifi Map voltageLevelDefaultLimits, VoltageLevel voltageLevel, Map voltageLevelsIdsRestricted) { - if (voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) || voltageLevelModificationLimits.containsKey(voltageLevel.getId())) { - setLowVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, voltageLevel, voltageLevelsIdsRestricted); - setHighVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, voltageLevel); - } + setLowVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, voltageLevel, voltageLevelsIdsRestricted); + setHighVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, voltageLevel); } private static void setLowVoltageLimit(List specificVoltageLimits, @@ -112,31 +110,28 @@ private static void setLowVoltageLimit(List specificVoltag Map voltageLevelDefaultLimits, VoltageLevel voltageLevel, Map voltageLevelsIdsRestricted) { - final String voltageLevelId = voltageLevel.getId(); - final boolean isLowVoltageLimitModificationSet = voltageLevelModificationLimits.containsKey(voltageLevelId) && voltageLevelModificationLimits.get(voltageLevelId).getLowVoltageLimit() != null; - final double lowVoltageLimit = voltageLevel.getLowVoltageLimit(); + boolean isLowVoltageLimitModificationSet = voltageLevelModificationLimits.containsKey(voltageLevel.getId()) && voltageLevelModificationLimits.get(voltageLevel.getId()).getLowVoltageLimit() != null; + boolean isLowVoltageLimitDefaultSet = voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) && voltageLevelDefaultLimits.get(voltageLevel.getId()).getLowVoltageLimit() != null; double newLowVoltageLimit; - if (!Double.isNaN(lowVoltageLimit) && isLowVoltageLimitModificationSet) { - double lowVoltageLimitModification = voltageLevelModificationLimits.get(voltageLevelId).getLowVoltageLimit(); - if (lowVoltageLimit + lowVoltageLimitModification < 0) { - newLowVoltageLimit = lowVoltageLimit * -1; - voltageLevelsIdsRestricted.put(voltageLevelId, newLowVoltageLimit); + if (!Double.isNaN(voltageLevel.getLowVoltageLimit()) && isLowVoltageLimitModificationSet) { + double lowVoltageLimitModification = voltageLevelModificationLimits.get(voltageLevel.getId()).getLowVoltageLimit(); + if (voltageLevel.getLowVoltageLimit() + lowVoltageLimitModification < 0) { + newLowVoltageLimit = voltageLevel.getLowVoltageLimit() * -1; + voltageLevelsIdsRestricted.put(voltageLevel.getId(), newLowVoltageLimit); } else { newLowVoltageLimit = lowVoltageLimitModification; } - specificVoltageLimits.add(new VoltageLimitOverride(voltageLevelId, VoltageLimitType.LOW_VOLTAGE_LIMIT, true, newLowVoltageLimit)); + specificVoltageLimits.add(new VoltageLimitOverride(voltageLevel.getId(), VoltageLimitType.LOW_VOLTAGE_LIMIT, true, newLowVoltageLimit)); - } else if (Double.isNaN(lowVoltageLimit) - && voltageLevelDefaultLimits.containsKey(voltageLevelId) - && voltageLevelDefaultLimits.get(voltageLevelId).getLowVoltageLimit() != null) { - double voltageLimit = voltageLevelDefaultLimits.get(voltageLevelId).getLowVoltageLimit() + (isLowVoltageLimitModificationSet ? voltageLevelModificationLimits.get(voltageLevelId).getLowVoltageLimit() : 0.); + } else if (Double.isNaN(voltageLevel.getLowVoltageLimit()) && isLowVoltageLimitDefaultSet) { + double voltageLimit = voltageLevelDefaultLimits.get(voltageLevel.getId()).getLowVoltageLimit() + (isLowVoltageLimitModificationSet ? voltageLevelModificationLimits.get(voltageLevel.getId()).getLowVoltageLimit() : 0.); if (voltageLimit < 0) { newLowVoltageLimit = 0.0; - voltageLevelsIdsRestricted.put(voltageLevelId, newLowVoltageLimit); + voltageLevelsIdsRestricted.put(voltageLevel.getId(), newLowVoltageLimit); } else { newLowVoltageLimit = voltageLimit; } - specificVoltageLimits.add(new VoltageLimitOverride(voltageLevelId, VoltageLimitType.LOW_VOLTAGE_LIMIT, false, newLowVoltageLimit)); + specificVoltageLimits.add(new VoltageLimitOverride(voltageLevel.getId(), VoltageLimitType.LOW_VOLTAGE_LIMIT, false, newLowVoltageLimit)); } } @@ -144,25 +139,12 @@ private static void setHighVoltageLimit(List specificVolta Map voltageLevelModificationLimits, Map voltageLevelDefaultLimits, VoltageLevel voltageLevel) { - final String voltageLevelId = voltageLevel.getId(); - final boolean isHighVoltageLimitModificationSet = voltageLevelModificationLimits.containsKey(voltageLevelId) && voltageLevelModificationLimits.get(voltageLevelId).getHighVoltageLimit() != null; - final double highVoltageLimit = voltageLevel.getHighVoltageLimit(); - if (!Double.isNaN(highVoltageLimit) && isHighVoltageLimitModificationSet) { - specificVoltageLimits.add(new VoltageLimitOverride( - voltageLevelId, - VoltageLimitType.HIGH_VOLTAGE_LIMIT, - true, - voltageLevelModificationLimits.get(voltageLevelId).getHighVoltageLimit() - )); - } else if (Double.isNaN(highVoltageLimit) - && voltageLevelDefaultLimits.containsKey(voltageLevelId) - && voltageLevelDefaultLimits.get(voltageLevelId).getHighVoltageLimit() != null) { - specificVoltageLimits.add(new VoltageLimitOverride( - voltageLevelId, - VoltageLimitType.HIGH_VOLTAGE_LIMIT, - false, - voltageLevelDefaultLimits.get(voltageLevelId).getHighVoltageLimit() + (isHighVoltageLimitModificationSet ? voltageLevelModificationLimits.get(voltageLevelId).getHighVoltageLimit() : 0.) - )); + boolean isHighVoltageLimitModificationSet = voltageLevelModificationLimits.containsKey(voltageLevel.getId()) && voltageLevelModificationLimits.get(voltageLevel.getId()).getHighVoltageLimit() != null; + boolean isHighVoltageLimitDefaultSet = voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) && voltageLevelDefaultLimits.get(voltageLevel.getId()).getHighVoltageLimit() != null; + if (!Double.isNaN(voltageLevel.getHighVoltageLimit()) && isHighVoltageLimitModificationSet) { + specificVoltageLimits.add(new VoltageLimitOverride(voltageLevel.getId(), VoltageLimitType.HIGH_VOLTAGE_LIMIT, true, voltageLevelModificationLimits.get(voltageLevel.getId()).getHighVoltageLimit())); + } else if (Double.isNaN(voltageLevel.getHighVoltageLimit()) && isHighVoltageLimitDefaultSet) { + specificVoltageLimits.add(new VoltageLimitOverride(voltageLevel.getId(), VoltageLimitType.HIGH_VOLTAGE_LIMIT, false, voltageLevelDefaultLimits.get(voltageLevel.getId()).getHighVoltageLimit() + (isHighVoltageLimitModificationSet ? voltageLevelModificationLimits.get(voltageLevel.getId()).getHighVoltageLimit() : 0.))); } } @@ -255,14 +237,14 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, private List toEquipmentIdsList(UUID networkUuid, String variantId, List filters) { if (filters == null || filters.isEmpty()) { return List.of(); - } else { - return filterService.exportFilters(filters.stream().map(FilterEquipmentsEmbeddable::getFilterId).toList(), networkUuid, variantId) - .stream() - .map(FilterEquipments::getIdentifiableAttributes) - .flatMap(List::stream) - .map(IdentifiableAttributes::getId) - .distinct() - .toList(); } + List equipments = filterService.exportFilters(filters.stream().map(FilterEquipmentsEmbeddable::getFilterId).toList(), networkUuid, variantId); + Set ids = new HashSet<>(); + equipments.forEach(filterEquipment -> + filterEquipment.getIdentifiableAttributes().forEach(identifiableAttribute -> + ids.add(identifiableAttribute.getId()) + ) + ); + return new ArrayList<>(ids); } } diff --git a/src/test/java/org/gridsuite/voltageinit/server/SupervisionControllerTest.java b/src/test/java/org/gridsuite/voltageinit/server/SupervisionControllerTest.java index f51e3899..b5beb596 100644 --- a/src/test/java/org/gridsuite/voltageinit/server/SupervisionControllerTest.java +++ b/src/test/java/org/gridsuite/voltageinit/server/SupervisionControllerTest.java @@ -6,31 +6,35 @@ */ package org.gridsuite.voltageinit.server; -import org.junit.jupiter.api.Test; +import org.junit.Test; +import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.http.MediaType; +import org.springframework.test.context.junit4.SpringRunner; import org.springframework.test.web.servlet.MockMvc; import org.springframework.test.web.servlet.MvcResult; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; +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; +import static org.junit.Assert.assertEquals; + /** * @author Hugo Marcellin */ +@RunWith(SpringRunner.class) @AutoConfigureMockMvc @SpringBootTest -class SupervisionControllerTest { +public class SupervisionControllerTest { @Autowired private MockMvc mockMvc; @Test - void testResultCount() throws Exception { + public void testResultCount() throws Exception { //get the result timeline uuid of the calculation MvcResult mvcResult = mockMvc.perform(get("/v1/supervision/results-count")) .andExpect(status().isOk()) @@ -39,6 +43,7 @@ void testResultCount() throws Exception { String resultCount = mvcResult.getResponse().getContentAsString(); assertEquals("0", resultCount); + } } diff --git a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitControllerTest.java b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitControllerTest.java index d8b906a7..638667d4 100644 --- a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitControllerTest.java +++ b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitControllerTest.java @@ -27,6 +27,7 @@ import com.powsybl.openreac.parameters.input.OpenReacParameters; import com.powsybl.openreac.parameters.output.OpenReacResult; import com.powsybl.openreac.parameters.output.OpenReacStatus; +import lombok.SneakyThrows; import okhttp3.HttpUrl; import okhttp3.mockwebserver.Dispatcher; import okhttp3.mockwebserver.MockResponse; @@ -44,13 +45,13 @@ import org.gridsuite.voltageinit.server.service.parameters.FilterService; import org.gridsuite.voltageinit.server.util.annotations.PostCompletionAdapter; import org.jgrapht.alg.util.Pair; -import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; import org.mockito.MockedStatic; import org.mockito.Mockito; -import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.MockitoAnnotations; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc; import org.springframework.boot.test.context.SpringBootTest; @@ -59,10 +60,9 @@ import org.springframework.cloud.stream.binder.test.TestChannelBinderConfiguration; import org.springframework.http.MediaType; import org.springframework.messaging.Message; -import org.springframework.test.annotation.DirtiesContext; -import org.springframework.test.annotation.DirtiesContext.ClassMode; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.ContextHierarchy; +import org.springframework.test.context.junit4.SpringRunner; import org.springframework.test.web.servlet.MockMvc; import org.springframework.test.web.servlet.MvcResult; import org.springframework.transaction.support.TransactionSynchronizationManager; @@ -76,8 +76,8 @@ import static com.powsybl.network.store.model.NetworkStoreApi.VERSION; import static org.gridsuite.voltageinit.server.service.NotificationService.CANCEL_MESSAGE; import static org.gridsuite.voltageinit.server.service.NotificationService.HEADER_USER_ID; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.BDDMockito.given; @@ -88,12 +88,12 @@ /** * @author Etienne Homer */ -@ExtendWith({ MockitoExtension.class }) -@SpringBootTest +@RunWith(SpringRunner.class) @AutoConfigureMockMvc -@DirtiesContext(classMode = ClassMode.AFTER_EACH_TEST_METHOD) +@SpringBootTest @ContextHierarchy({@ContextConfiguration(classes = {VoltageInitApplication.class, TestChannelBinderConfiguration.class})}) -class VoltageInitControllerTest { +public class VoltageInitControllerTest { + private static final UUID NETWORK_UUID = UUID.fromString("7928181c-7977-4592-ba19-88027e4254e4"); private static final UUID OTHER_NETWORK_UUID = UUID.fromString("06824085-db85-4883-9458-8c5c9f1585d6"); private static final UUID RESULT_UUID = UUID.fromString("0c8de370-3e6c-4d72-b292-d355a97e0d5d"); @@ -131,17 +131,18 @@ class VoltageInitControllerTest { @MockBean private UuidGeneratorService uuidGeneratorService; - @Autowired - private ObjectMapper mapper; + private final RestTemplateConfig restTemplateConfig = new RestTemplateConfig(); + private final ObjectMapper mapper = restTemplateConfig.objectMapper(); private Network network; - private OpenReacResult openReacResult; - private CompletableFutureTask completableFutureResultsTask; + OpenReacParameters openReacParameters; + OpenReacResult openReacResult; + CompletableFutureTask completableFutureResultsTask; - public MockWebServer server; + private MockWebServer server; - private void buildOpenReacResult() { - OpenReacAmplIOFiles openReacAmplIOFiles = new OpenReacAmplIOFiles(new OpenReacParameters(), network, false); + private OpenReacResult buildOpenReacResult() { + OpenReacAmplIOFiles openReacAmplIOFiles = new OpenReacAmplIOFiles(openReacParameters, network, false); GeneratorModification.Modifs m1 = new GeneratorModification.Modifs(); m1.setTargetV(228.); @@ -164,9 +165,10 @@ private void buildOpenReacResult() { voltageProfile.put("SHUNT_1_busId1", Pair.of(100., 100.)); openReacResult = new OpenReacResult(OpenReacStatus.OK, openReacAmplIOFiles, INDICATORS); + return openReacResult; } - private static VoltageInitParametersEntity buildVoltageInitParametersEntity() { + private VoltageInitParametersEntity buildVoltageInitParametersEntity() { return VoltageInitParametersInfos.builder() .voltageLimitsModification(List.of(VoltageLimitInfos.builder() .priority(0) @@ -201,8 +203,10 @@ private static VoltageInitParametersEntity buildVoltageInitParametersEntity() { .build().toEntity(); } - @BeforeEach + @Before public void setUp() throws Exception { + MockitoAnnotations.initMocks(this); + server = new MockWebServer(); server.start(); @@ -237,20 +241,24 @@ public void setUp() throws Exception { given(networkStoreService.getNetwork(OTHER_NETWORK_UUID, PreloadingStrategy.ALL_COLLECTIONS_NEEDED_FOR_BUS_VIEW)).willThrow(new PowsyblException("Not found")); // OpenReac run mocking - buildOpenReacResult(); + openReacParameters = new OpenReacParameters(); + openReacResult = buildOpenReacResult(); + completableFutureResultsTask = CompletableFutureTask.runAsync(() -> openReacResult, ForkJoinPool.commonPool()); // UUID service mocking to always generate the same result UUID given(uuidGeneratorService.generate()).willReturn(RESULT_UUID); final Dispatcher dispatcher = new Dispatcher() { + @SneakyThrows @Override public MockResponse dispatch(RecordedRequest request) { String path = Objects.requireNonNull(request.getPath()); - if (path.matches("/v1/groups/.*") && "DELETE".equals(request.getMethod())) { + + if (path.matches("/v1/groups/.*") && request.getMethod().equals("DELETE")) { return new MockResponse().setResponseCode(200) .addHeader("Content-Type", "application/json; charset=utf-8"); - } else if (path.matches("/v1/groups/modification") && "POST".equals(request.getMethod())) { + } else if (path.matches("/v1/groups/modification") && request.getMethod().equals("POST")) { return new MockResponse().setResponseCode(200).setBody("\"" + MODIFICATIONS_GROUP_UUID + "\"") .addHeader("Content-Type", "application/json; charset=utf-8"); } else if (path.matches("/v1/filters/export\\?networkUuid=" + NETWORK_UUID + "&variantId=" + VARIANT_2_ID + "&ids=.*")) { @@ -276,13 +284,15 @@ public MockResponse dispatch(RecordedRequest request) { } } - @AfterEach - public void tearDown() throws Exception { - server.shutdown(); + @SneakyThrows + @After + public void tearDown() { + mockMvc.perform(delete("/" + VERSION + "/results")) + .andExpect(status().isOk()); } @Test - void runTest() throws Exception { + public void runTest() throws Exception { try (MockedStatic openReacRunnerMockedStatic = Mockito.mockStatic(OpenReacRunner.class)) { openReacRunnerMockedStatic.when(() -> OpenReacRunner.runAsync(eq(network), eq(VARIANT_2_ID), any(OpenReacParameters.class), any(OpenReacConfig.class), any(ComputationManager.class))) .thenReturn(completableFutureResultsTask); @@ -345,7 +355,7 @@ void runTest() throws Exception { } @Test - void runWrongNetworkTest() throws Exception { + public void runWrongNetworkTest() throws Exception { MvcResult result = mockMvc.perform(post( "/" + VERSION + "/networks/{networkUuid}/run-and-save?receiver=me&variantId=" + VARIANT_2_ID, OTHER_NETWORK_UUID) .header(HEADER_USER_ID, "userId")) @@ -366,7 +376,7 @@ void runWrongNetworkTest() throws Exception { } @Test - void runWithReportTest() throws Exception { + public void runWithReportTest() throws Exception { MvcResult result = mockMvc.perform(post( "/" + VERSION + "/networks/{networkUuid}/run-and-save?receiver=me&variantId={variantId}&reportType=VoltageInit&reportUuid=" + REPORT_UUID + "&reporterId=" + UUID.randomUUID(), NETWORK_UUID, VARIANT_2_ID) .header(HEADER_USER_ID, "userId")) @@ -376,7 +386,7 @@ void runWithReportTest() throws Exception { } @Test - void stopTest() throws Exception { + public void stopTest() throws Exception { try (MockedStatic openReacRunnerMockedStatic = Mockito.mockStatic(OpenReacRunner.class)) { openReacRunnerMockedStatic.when(() -> OpenReacRunner.runAsync(eq(network), eq(VARIANT_2_ID), any(OpenReacParameters.class), any(OpenReacConfig.class), any(ComputationManager.class))) .thenReturn(completableFutureResultsTask); @@ -402,8 +412,9 @@ void stopTest() throws Exception { } } + @SneakyThrows @Test - void getStatusTest() throws Exception { + public void getStatusTest() { MvcResult result = mockMvc.perform(get( "/" + VERSION + "/results/{resultUuid}/status", RESULT_UUID)) .andExpect(status().isOk()) @@ -421,8 +432,9 @@ void getStatusTest() throws Exception { assertEquals(VoltageInitStatus.NOT_DONE.name(), result.getResponse().getContentAsString()); } + @SneakyThrows @Test - void postCompletionAdapterTest() { + public void postCompletionAdapterTest() { CompletableFutureTask task = CompletableFutureTask.runAsync(() -> openReacResult, ForkJoinPool.commonPool()); PostCompletionAdapter adapter = new PostCompletionAdapter(); adapter.execute(task); diff --git a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java index 72237d9e..758479bf 100644 --- a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java +++ b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java @@ -19,7 +19,7 @@ import com.powsybl.openreac.parameters.input.OpenReacParameters; import com.powsybl.openreac.parameters.input.VoltageLimitOverride; import com.powsybl.openreac.parameters.input.VoltageLimitOverride.VoltageLimitType; -import org.apache.commons.lang3.builder.ToStringBuilder; +import lombok.extern.slf4j.Slf4j; import org.assertj.core.api.Condition; import org.assertj.core.api.ListAssert; import org.gridsuite.voltageinit.server.dto.parameters.FilterEquipments; @@ -60,7 +60,6 @@ import java.util.Objects; import java.util.UUID; import java.util.function.Consumer; -import java.util.stream.Collectors; import java.util.stream.Stream; import static org.assertj.core.api.Assertions.assertThat; @@ -75,9 +74,10 @@ * @author Ayoub LABIDI */ @SpringBootTest -@DirtiesContext(classMode = ClassMode.AFTER_EACH_TEST_METHOD) +@DirtiesContext(classMode = ClassMode.BEFORE_EACH_TEST_METHOD) @AutoConfigureMockMvc @Transactional +@Slf4j class VoltageInitParametersTest { private static final String URI_PARAMETERS_BASE = "/v1/parameters"; private static final String URI_PARAMETERS_GET_PUT = URI_PARAMETERS_BASE + "/"; @@ -144,73 +144,101 @@ public void setup() { @Test void testCreate() throws Exception { VoltageInitParametersInfos parametersToCreate = buildParameters(); - mockMvc.perform(post(URI_PARAMETERS_BASE).content(mapper.writeValueAsString(parametersToCreate)).contentType(MediaType.APPLICATION_JSON)) - .andExpect(status().isOk()).andReturn(); - assertThat(parametersRepository.findAll().get(0).toVoltageInitParametersInfos()) - .as("created parameters") - .recursivelyEquals(parametersToCreate); + String parametersToCreateJson = mapper.writeValueAsString(parametersToCreate); + + mockMvc.perform(post(URI_PARAMETERS_BASE).content(parametersToCreateJson).contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()).andReturn(); + + VoltageInitParametersInfos createdParameters = parametersRepository.findAll().get(0).toVoltageInitParametersInfos(); + + assertThat(createdParameters).recursivelyEquals(parametersToCreate); } @Test void testRead() throws Exception { VoltageInitParametersInfos parametersToRead = buildParameters(); + UUID parametersUuid = saveAndReturnId(parametersToRead); + MvcResult mvcResult = mockMvc.perform(get(URI_PARAMETERS_GET_PUT + parametersUuid)) - .andExpect(status().isOk()).andReturn(); + .andExpect(status().isOk()).andReturn(); String resultAsString = mvcResult.getResponse().getContentAsString(); - assertThat(mapper.readValue(resultAsString, new TypeReference() { })) - .as("received parameters") - .recursivelyEquals(parametersToRead); + VoltageInitParametersInfos receivedParameters = mapper.readValue(resultAsString, new TypeReference<>() { + }); + + assertThat(receivedParameters).recursivelyEquals(parametersToRead); } @Test void testUpdate() throws Exception { - UUID parametersUuid = saveAndReturnId(buildParameters()); - VoltageInitParametersInfos parametersToUpdate = buildParametersUpdate(); - mockMvc.perform(put(URI_PARAMETERS_GET_PUT + parametersUuid).content(mapper.writeValueAsString(parametersToUpdate)).contentType(MediaType.APPLICATION_JSON)) - .andExpect(status().isOk()); - assertThat(parametersRepository.findById(parametersUuid).get().toVoltageInitParametersInfos()) - .as("updated parameters") - .recursivelyEquals(parametersToUpdate); + VoltageInitParametersInfos parametersToUpdate = buildParameters(); + + UUID parametersUuid = saveAndReturnId(parametersToUpdate); + + parametersToUpdate = buildParametersUpdate(); + + String parametersToUpdateJson = mapper.writeValueAsString(parametersToUpdate); + + mockMvc.perform(put(URI_PARAMETERS_GET_PUT + parametersUuid).content(parametersToUpdateJson).contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()); + + VoltageInitParametersInfos updatedParameters = parametersRepository.findById(parametersUuid).get().toVoltageInitParametersInfos(); + + assertThat(updatedParameters).recursivelyEquals(parametersToUpdate); } @Test void testDelete() throws Exception { - UUID parametersUuid = saveAndReturnId(buildParameters()); + VoltageInitParametersInfos parametersToDelete = buildParameters(); + + UUID parametersUuid = saveAndReturnId(parametersToDelete); + mockMvc.perform(delete(URI_PARAMETERS_GET_PUT + parametersUuid)).andExpect(status().isOk()).andReturn(); assertThat(parametersRepository.count()).as("parameters repository items count").isZero(); } @Test void testGetAll() throws Exception { - saveAndReturnId(buildParameters()); - saveAndReturnId(buildParametersUpdate()); + VoltageInitParametersInfos parameters1 = buildParameters(); + + VoltageInitParametersInfos parameters2 = buildParametersUpdate(); + + saveAndReturnId(parameters1); + + saveAndReturnId(parameters2); + MvcResult mvcResult = mockMvc.perform(get(URI_PARAMETERS_BASE)) - .andExpect(status().isOk()).andReturn(); + .andExpect(status().isOk()).andReturn(); String resultAsString = mvcResult.getResponse().getContentAsString(); - assertThat(mapper.readValue(resultAsString, new TypeReference>() { })) - .as("received parameters") - .hasSize(2); + List receivedParameters = mapper.readValue(resultAsString, new TypeReference<>() { + }); + + assertThat(receivedParameters).hasSize(2); } @Test void testDuplicate() throws Exception { - mockMvc.perform(post(URI_PARAMETERS_BASE).content(mapper.writeValueAsString(buildParameters())).contentType(MediaType.APPLICATION_JSON)) - .andExpect(status().isOk()).andReturn(); + VoltageInitParametersInfos parametersToCreate = buildParameters(); + String parametersToCreateJson = mapper.writeValueAsString(parametersToCreate); + mockMvc.perform(post(URI_PARAMETERS_BASE).content(parametersToCreateJson).contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()).andReturn(); VoltageInitParametersInfos createdParameters = parametersRepository.findAll().get(0).toVoltageInitParametersInfos(); - mockMvc.perform(post(URI_PARAMETERS_BASE).param("duplicateFrom", UUID.randomUUID().toString())) - .andExpect(status().isNotFound()); - mockMvc.perform(post(URI_PARAMETERS_BASE).param("duplicateFrom", createdParameters.getUuid().toString())) - .andExpect(status().isOk()); - assertThat(parametersRepository.findAll().get(1).toVoltageInitParametersInfos()) - .as("duplicated parameters") - .recursivelyEquals(createdParameters); + + mockMvc.perform(post(URI_PARAMETERS_BASE) + .param("duplicateFrom", UUID.randomUUID().toString())) + .andExpect(status().isNotFound()); + + mockMvc.perform(post(URI_PARAMETERS_BASE) + .param("duplicateFrom", createdParameters.getUuid().toString())) + .andExpect(status().isOk()); + + VoltageInitParametersInfos duplicatedParameters = parametersRepository.findAll().get(1).toVoltageInitParametersInfos(); + assertThat(duplicatedParameters).recursivelyEquals(createdParameters); } /** Save parameters into the repository and return its UUID. */ private UUID saveAndReturnId(VoltageInitParametersInfos parametersInfos) { - parametersRepository.save(parametersInfos.toEntity()); - return parametersRepository.findAll().get(0).getId(); + return parametersRepository.save(parametersInfos.toEntity()).getId(); } private static VoltageInitParametersInfos buildParameters() { @@ -295,8 +323,7 @@ List dynamicTestsBuildSpecificVoltageLimits() { ); final VoltageInitRunContext context = new VoltageInitRunContext(NETWORK_UUID, VARIANT_ID_1, null, REPORT_UUID, null, "", "", voltageInitParameters.getId()); final OpenReacParameters openReacParameters = voltageInitParametersService.buildOpenReacParameters(context, network); - /*TODO*/System.out.println(parametersRepository.findAll().stream().map(ToStringBuilder::reflectionToString).collect(Collectors.joining())); - /*TODO*/System.out.println(mapper.writeValueAsString(context.getRootReporter())); + log.debug("openReac build parameters report: {}", mapper.writeValueAsString(context.getRootReporter())); JSONAssert.assertEquals("build parameters logs", TestUtils.resourceToString(reportFilename), mapper.writeValueAsString(context.getRootReporter()), REPORTER_COMPARATOR); return assertThat(openReacParameters.getSpecificVoltageLimits()).as("SpecificVoltageLimits"); }; diff --git a/src/test/java/org/gridsuite/voltageinit/service/ReportServiceTest.java b/src/test/java/org/gridsuite/voltageinit/service/ReportServiceTest.java index ef17a221..878c0827 100644 --- a/src/test/java/org/gridsuite/voltageinit/service/ReportServiceTest.java +++ b/src/test/java/org/gridsuite/voltageinit/service/ReportServiceTest.java @@ -13,13 +13,15 @@ import com.powsybl.commons.reporter.ReporterModel; import org.gridsuite.voltageinit.server.service.ReportService; import org.gridsuite.voltageinit.utils.ContextConfigurationWithTestChannel; -import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.boot.test.mock.mockito.MockBean; import org.springframework.http.*; +import org.springframework.test.context.junit4.SpringRunner; import org.springframework.web.client.RestTemplate; import org.springframework.web.util.UriComponentsBuilder; @@ -30,6 +32,7 @@ import static com.github.tomakehurst.wiremock.client.WireMock.*; import static org.gridsuite.voltageinit.utils.TestUtils.resourceToString; +import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; @@ -37,8 +40,9 @@ * @author Anis TOURI */ @SpringBootTest +@RunWith(SpringRunner.class) @ContextConfigurationWithTestChannel -class ReportServiceTest { +public class ReportServiceTest { private static final UUID REPORT_UUID = UUID.fromString("7928181c-7977-4592-ba19-88027e4254e4"); private static final String BASE_URI = "http://localhost:"; @@ -60,7 +64,7 @@ private void configureWireMockServer(String reportJson) { } - @BeforeEach + @Before public void setUp() throws IOException, URISyntaxException { String reportJson = resourceToString("report.json"); server = new WireMockServer(WireMockConfiguration.wireMockConfig().dynamicPort()); @@ -72,23 +76,23 @@ public void setUp() throws IOException, URISyntaxException { reportService.setReportServiceBaseUri("http://localhost:" + server.port()); } - @AfterEach + @After public void tearDown() { server.stop(); } @Test - void testSendReport() { + public void testSendReport() { Reporter reporter = new ReporterModel("test", "test"); URI expectedUri = UriComponentsBuilder .fromPath(DELIMITER + REPORT_API_VERSION + "/reports/{reportUuid}") .build(REPORT_UUID); reportService.sendReport(REPORT_UUID, reporter); - verify(restTemplate, times(1)).put(BASE_URI + server.port() + expectedUri, reporter); + verify(restTemplate, times(1)).put(eq(BASE_URI + server.port() + expectedUri), eq(reporter)); } @Test - void testDeleteReport() { + public void testDeleteReport() { reportService.deleteReport(REPORT_UUID, "VoltageInit"); URI expectedUri = UriComponentsBuilder .fromPath(DELIMITER + REPORT_API_VERSION + "/reports/{reportUuid}") @@ -97,6 +101,6 @@ void testDeleteReport() { .build(REPORT_UUID); HttpHeaders headers = new HttpHeaders(); headers.setContentType(MediaType.APPLICATION_JSON); - verify(restTemplate, times(1)).exchange(BASE_URI + server.port() + expectedUri, HttpMethod.DELETE, new HttpEntity<>(headers), Void.class); + verify(restTemplate, times(1)).exchange(eq(BASE_URI + server.port() + expectedUri), eq(HttpMethod.DELETE), eq(new HttpEntity<>(headers)), eq(Void.class)); } } From 438e19957c635c2e47061561f0f627b17bc7134d Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Wed, 27 Mar 2024 16:52:40 +0100 Subject: [PATCH 17/53] review replace `@TestFactory` by individual `@Test` --- .../server/VoltageInitParametersTest.java | 128 ++++++++++-------- 1 file changed, 71 insertions(+), 57 deletions(-) diff --git a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java index 758479bf..5f7af518 100644 --- a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java +++ b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java @@ -36,9 +36,8 @@ import org.gridsuite.voltageinit.server.util.VoltageLimitParameterType; import org.gridsuite.voltageinit.utils.TestUtils; import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.DynamicTest; +import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.TestFactory; import org.skyscreamer.jsonassert.Customization; import org.skyscreamer.jsonassert.JSONAssert; import org.skyscreamer.jsonassert.JSONCompareMode; @@ -54,7 +53,6 @@ import org.springframework.test.web.servlet.MockMvc; import org.springframework.test.web.servlet.MvcResult; import org.springframework.transaction.annotation.Transactional; -import org.springframework.util.function.ThrowingBiFunction; import java.util.List; import java.util.Objects; @@ -90,6 +88,12 @@ class VoltageInitParametersTest { private static final String FILTER_2 = "FILTER_2"; private static final UUID REPORT_UUID = UUID.fromString("00000000-0000-0000-0000-000000000000"); + private static final VoltageLimitEntity VOLTAGE_LIMIT = new VoltageLimitEntity(UUID.randomUUID(), 5., 10., 0, VoltageLimitParameterType.DEFAULT, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); + private static final VoltageLimitEntity VOLTAGE_LIMIT_2 = new VoltageLimitEntity(UUID.randomUUID(), 44., 88., 1, VoltageLimitParameterType.DEFAULT, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_2, FILTER_2))); + private static final VoltageLimitEntity VOLTAGE_LIMIT_3 = new VoltageLimitEntity(UUID.randomUUID(), -1., -2., 0, VoltageLimitParameterType.MODIFICATION, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); + private static final VoltageLimitEntity VOLTAGE_LIMIT_4 = new VoltageLimitEntity(UUID.randomUUID(), -20.0, 10.0, 0, VoltageLimitParameterType.MODIFICATION, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); + private static final VoltageLimitEntity VOLTAGE_LIMIT_5 = new VoltageLimitEntity(UUID.randomUUID(), 10.0, 10.0, 0, VoltageLimitParameterType.DEFAULT, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); + private static final JSONComparator REPORTER_COMPARATOR = new CustomComparator(JSONCompareMode.STRICT, // ignore field having uuid changing each run new Customization("reportTree.subReporters[*].taskValues.parameters_id.value", (o1, o2) -> (o1 == null) == (o2 == null)) @@ -315,61 +319,71 @@ private static Consumer assertVoltageLimitOverride(final S ).filter(Objects::nonNull).toArray(Condition[]::new))); } - @TestFactory - List dynamicTestsBuildSpecificVoltageLimits() { - final ThrowingBiFunction, String, ListAssert> initTestEnv = (voltageLimits, reportFilename) -> { - final VoltageInitParametersEntity voltageInitParameters = parametersRepository.save( + private ListAssert testsBuildSpecificVoltageLimitsCommon(List voltageLimits, String reportFilename) throws Exception { + final VoltageInitParametersEntity voltageInitParameters = parametersRepository.save( new VoltageInitParametersEntity(UUID.randomUUID(), null, "", voltageLimits, null, null, null) - ); - final VoltageInitRunContext context = new VoltageInitRunContext(NETWORK_UUID, VARIANT_ID_1, null, REPORT_UUID, null, "", "", voltageInitParameters.getId()); - final OpenReacParameters openReacParameters = voltageInitParametersService.buildOpenReacParameters(context, network); - log.debug("openReac build parameters report: {}", mapper.writeValueAsString(context.getRootReporter())); - JSONAssert.assertEquals("build parameters logs", TestUtils.resourceToString(reportFilename), mapper.writeValueAsString(context.getRootReporter()), REPORTER_COMPARATOR); - return assertThat(openReacParameters.getSpecificVoltageLimits()).as("SpecificVoltageLimits"); - }; - final VoltageLimitEntity voltageLimit = new VoltageLimitEntity(UUID.randomUUID(), 5., 10., 0, VoltageLimitParameterType.DEFAULT, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); - final VoltageLimitEntity voltageLimit2 = new VoltageLimitEntity(UUID.randomUUID(), 44., 88., 1, VoltageLimitParameterType.DEFAULT, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_2, FILTER_2))); - final VoltageLimitEntity voltageLimit3 = new VoltageLimitEntity(UUID.randomUUID(), -1., -2., 0, VoltageLimitParameterType.MODIFICATION, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); - final VoltageLimitEntity voltageLimit4 = new VoltageLimitEntity(UUID.randomUUID(), -20.0, 10.0, 0, VoltageLimitParameterType.MODIFICATION, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); - final VoltageLimitEntity voltageLimit5 = new VoltageLimitEntity(UUID.randomUUID(), 10.0, 10.0, 0, VoltageLimitParameterType.DEFAULT, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); - return List.of( - DynamicTest.dynamicTest("No voltage limit modification", () -> initTestEnv.apply(List.of(voltageLimit, voltageLimit2), "reporter_buildOpenReacParameters.json") - .hasSize(4) - //No override should be relative since there is no voltage limit modification - .noneMatch(VoltageLimitOverride::isRelative) - //VLHV1, VLHV2 and VLLOAD should be applied default voltage limits since those are missing one or both limits - .satisfiesExactlyInAnyOrder( - assertVoltageLimitOverride("VLHV1", VoltageLimitType.LOW_VOLTAGE_LIMIT), - assertVoltageLimitOverride("VLHV2", VoltageLimitType.HIGH_VOLTAGE_LIMIT), - //The voltage limits attributed to VLLOAD should respectively be 44. and 88. since the priority of FILTER_2, related to VLLOAD, is higher than FILTER_1 - assertVoltageLimitOverride("VLLOAD", VoltageLimitType.LOW_VOLTAGE_LIMIT, 44.), - assertVoltageLimitOverride("VLLOAD", VoltageLimitType.HIGH_VOLTAGE_LIMIT, 88.) - )), - //We now add limit modifications in additions to defaults settings - DynamicTest.dynamicTest("With voltage limit modifications", () -> initTestEnv.apply(List.of(voltageLimit, voltageLimit2, voltageLimit3), "reporter_buildOpenReacParameters_withLimitModifications.json") - //Limits that weren't impacted by default settings are now impacted by modification settings - .hasSize(8) - //There should (not?) be relative overrides since voltage limit modification are applied - .anyMatch(VoltageLimitOverride::isRelative) - //VLGEN has both it limits set so it should now be impacted by modifications override - .satisfiesOnlyOnce(assertVoltageLimitOverride("VLGEN", VoltageLimitType.LOW_VOLTAGE_LIMIT, -1.)) - .satisfiesOnlyOnce(assertVoltageLimitOverride("VLGEN", VoltageLimitType.HIGH_VOLTAGE_LIMIT, -2.)) - //Because of the modification setting the voltage limits attributed to VLLOAD should now respectively be 43. and 86. - .satisfiesOnlyOnce(assertVoltageLimitOverride("VLLOAD", VoltageLimitType.LOW_VOLTAGE_LIMIT, 43.)) - .satisfiesOnlyOnce(assertVoltageLimitOverride("VLLOAD", VoltageLimitType.HIGH_VOLTAGE_LIMIT, 86.))), - //note: VoltageLimitOverride implement equals() correctly, so we can use it - // We need to check for the case of relative = true with the modification less than 0 => the new low voltage limit = low voltage limit * -1 - DynamicTest.dynamicTest("Case relative true overrides", () -> initTestEnv.apply(List.of(voltageLimit4), "reporter_buildOpenReacParameters_caseRelativeTrue.json") - .hasSize(4) - // isRelative: There should have relative true overrides since voltage limit modification are applied for VLGEN - // getLimit: The low voltage limit must be impacted by the modification of the value - .containsOnlyOnce(new VoltageLimitOverride("VLGEN", VoltageLimitType.LOW_VOLTAGE_LIMIT, true, -10.0))), - // We need to check for the case of relative = false with the modification less than 0 => the new low voltage limit = 0 - DynamicTest.dynamicTest("Case relative false overrides", () -> initTestEnv.apply(List.of(voltageLimit4, voltageLimit5), "reporter_buildOpenReacParameters_caseRelativeFalse.json") - .hasSize(8) - // isRelative: There should have relative false overrides since voltage limit modification are applied for VLHV1 - // getLimit: The low voltage limit must be impacted by the modification of the value - .containsOnlyOnce(new VoltageLimitOverride("VLHV1", VoltageLimitType.LOW_VOLTAGE_LIMIT, false, 0.0))) ); + final VoltageInitRunContext context = new VoltageInitRunContext(NETWORK_UUID, VARIANT_ID_1, null, REPORT_UUID, null, "", "", voltageInitParameters.getId()); + final OpenReacParameters openReacParameters = voltageInitParametersService.buildOpenReacParameters(context, network); + log.debug("openReac build parameters report: {}", mapper.writeValueAsString(context.getRootReporter())); + JSONAssert.assertEquals("build parameters logs", TestUtils.resourceToString(reportFilename), mapper.writeValueAsString(context.getRootReporter()), REPORTER_COMPARATOR); + return assertThat(openReacParameters.getSpecificVoltageLimits()).as("SpecificVoltageLimits"); + } + + @DisplayName("buildSpecificVoltageLimits: No voltage limit modification") + @Test + void testsBuildSpecificVoltageLimitsSimple() throws Exception { + testsBuildSpecificVoltageLimitsCommon(List.of(VOLTAGE_LIMIT, VOLTAGE_LIMIT_2), "reporter_buildOpenReacParameters.json") + .hasSize(4) + //No override should be relative since there is no voltage limit modification + .noneMatch(VoltageLimitOverride::isRelative) + //VLHV1, VLHV2 and VLLOAD should be applied default voltage limits since those are missing one or both limits + .satisfiesExactlyInAnyOrder( + assertVoltageLimitOverride("VLHV1", VoltageLimitType.LOW_VOLTAGE_LIMIT), + assertVoltageLimitOverride("VLHV2", VoltageLimitType.HIGH_VOLTAGE_LIMIT), + //The voltage limits attributed to VLLOAD should respectively be 44. and 88. since the priority of FILTER_2, related to VLLOAD, is higher than FILTER_1 + assertVoltageLimitOverride("VLLOAD", VoltageLimitType.LOW_VOLTAGE_LIMIT, 44.), + assertVoltageLimitOverride("VLLOAD", VoltageLimitType.HIGH_VOLTAGE_LIMIT, 88.) + ); + } + + @DisplayName("buildSpecificVoltageLimits: With voltage limit modifications") + @Test + void testsBuildSpecificVoltageLimitsWithLimitModifications() throws Exception { + //We now add limit modifications in additions to defaults settings + testsBuildSpecificVoltageLimitsCommon(List.of(VOLTAGE_LIMIT, VOLTAGE_LIMIT_2, VOLTAGE_LIMIT_3), "reporter_buildOpenReacParameters_withLimitModifications.json") + //Limits that weren't impacted by default settings are now impacted by modification settings + .hasSize(8) + //There should (not?) be relative overrides since voltage limit modification are applied + .anyMatch(VoltageLimitOverride::isRelative) + //VLGEN has both it limits set so it should now be impacted by modifications override + .satisfiesOnlyOnce(assertVoltageLimitOverride("VLGEN", VoltageLimitType.LOW_VOLTAGE_LIMIT, -1.)) + .satisfiesOnlyOnce(assertVoltageLimitOverride("VLGEN", VoltageLimitType.HIGH_VOLTAGE_LIMIT, -2.)) + //Because of the modification setting the voltage limits attributed to VLLOAD should now respectively be 43. and 86. + .satisfiesOnlyOnce(assertVoltageLimitOverride("VLLOAD", VoltageLimitType.LOW_VOLTAGE_LIMIT, 43.)) + .satisfiesOnlyOnce(assertVoltageLimitOverride("VLLOAD", VoltageLimitType.HIGH_VOLTAGE_LIMIT, 86.)); + } + + @DisplayName("buildSpecificVoltageLimits: Case relative true overrides") + @Test + void testsBuildSpecificVoltageLimitsCaseRelativeTrue() throws Exception { + // We need to check for the case of relative = true with the modification less than 0 => the new low voltage limit = low voltage limit * -1 + testsBuildSpecificVoltageLimitsCommon(List.of(VOLTAGE_LIMIT_4), "reporter_buildOpenReacParameters_caseRelativeTrue.json") + .hasSize(4) + // isRelative: There should have relative true overrides since voltage limit modification are applied for VLGEN + // getLimit: The low voltage limit must be impacted by the modification of the value + .containsOnlyOnce(new VoltageLimitOverride("VLGEN", VoltageLimitType.LOW_VOLTAGE_LIMIT, true, -10.0)); + //note: VoltageLimitOverride implement equals() correctly, so we can use it + } + + @DisplayName("buildSpecificVoltageLimits: No voltage limit modification") + @Test + void testsBuildSpecificVoltageLimitsCaseRelativeFalse() throws Exception { + // We need to check for the case of relative = false with the modification less than 0 => the new low voltage limit = 0 + testsBuildSpecificVoltageLimitsCommon(List.of(VOLTAGE_LIMIT_4, VOLTAGE_LIMIT_5), "reporter_buildOpenReacParameters_caseRelativeFalse.json") + .hasSize(8) + // isRelative: There should have relative false overrides since voltage limit modification are applied for VLHV1 + // getLimit: The low voltage limit must be impacted by the modification of the value + .containsOnlyOnce(new VoltageLimitOverride("VLHV1", VoltageLimitType.LOW_VOLTAGE_LIMIT, false, 0.0)); } } From 68cf7b55f414924456750fa0cbca21090d1c6483 Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Wed, 27 Mar 2024 19:58:59 +0100 Subject: [PATCH 18/53] fix tests problem of SpringBoot contexts when mixing JUnit4 & JUnit5 --- .../server/VoltageInitControllerTest.java | 2 + .../VoltageInitParametersControllerTest.java | 219 +++++++++++++++++ .../VoltageInitParametersTest.java | 231 +++--------------- .../assertions/ReflectiveRepresentation.java | 11 +- 4 files changed, 260 insertions(+), 203 deletions(-) create mode 100644 src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersControllerTest.java rename src/test/java/org/gridsuite/voltageinit/server/{ => service/parameters}/VoltageInitParametersTest.java (51%) diff --git a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitControllerTest.java b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitControllerTest.java index 6cabfced..feb6b14e 100644 --- a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitControllerTest.java +++ b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitControllerTest.java @@ -61,6 +61,7 @@ import org.springframework.cloud.stream.binder.test.TestChannelBinderConfiguration; import org.springframework.http.MediaType; import org.springframework.messaging.Message; +import org.springframework.test.annotation.DirtiesContext; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.ContextHierarchy; import org.springframework.test.context.junit4.SpringRunner; @@ -91,6 +92,7 @@ */ @RunWith(SpringRunner.class) @AutoConfigureMockMvc +@DirtiesContext @SpringBootTest @ContextHierarchy({@ContextConfiguration(classes = {VoltageInitApplication.class, TestChannelBinderConfiguration.class})}) public class VoltageInitControllerTest { diff --git a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersControllerTest.java b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersControllerTest.java new file mode 100644 index 00000000..e47c7da4 --- /dev/null +++ b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersControllerTest.java @@ -0,0 +1,219 @@ +/** + * Copyright (c) 2023, 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.voltageinit.server; + +import com.fasterxml.jackson.core.type.TypeReference; +import com.fasterxml.jackson.databind.ObjectMapper; +import org.gridsuite.voltageinit.server.dto.parameters.FilterEquipments; +import org.gridsuite.voltageinit.server.dto.parameters.VoltageInitParametersInfos; +import org.gridsuite.voltageinit.server.dto.parameters.VoltageLimitInfos; +import org.gridsuite.voltageinit.server.entities.parameters.VoltageInitParametersEntity; +import org.gridsuite.voltageinit.server.repository.parameters.VoltageInitParametersRepository; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.http.MediaType; +import org.springframework.test.annotation.DirtiesContext; +import org.springframework.test.context.junit4.SpringRunner; +import org.springframework.test.web.servlet.MockMvc; +import org.springframework.test.web.servlet.MvcResult; +import org.springframework.transaction.annotation.Transactional; + +import java.util.List; +import java.util.UUID; + +import static org.gridsuite.voltageinit.utils.assertions.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; + +/** + * @author Ayoub LABIDI + */ +@RunWith(SpringRunner.class) +@SpringBootTest +@DirtiesContext +@AutoConfigureMockMvc +@Transactional +public class VoltageInitParametersControllerTest { + private static final String URI_PARAMETERS_BASE = "/v1/parameters"; + private static final String URI_PARAMETERS_GET_PUT = URI_PARAMETERS_BASE + "/"; + + @Autowired + private MockMvc mockMvc; + + @Autowired + private ObjectMapper mapper; + + @Autowired + private VoltageInitParametersRepository parametersRepository; + + @Test + public void testCreate() throws Exception { + + VoltageInitParametersInfos parametersToCreate = buildParameters(); + String parametersToCreateJson = mapper.writeValueAsString(parametersToCreate); + + mockMvc.perform(post(URI_PARAMETERS_BASE).content(parametersToCreateJson).contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()).andReturn(); + + VoltageInitParametersInfos createdParameters = parametersRepository.findAll().get(0).toVoltageInitParametersInfos(); + + assertThat(createdParameters).recursivelyEquals(parametersToCreate); + } + + @Test + public void testRead() throws Exception { + + VoltageInitParametersInfos parametersToRead = buildParameters(); + + UUID parametersUuid = saveAndRetunId(parametersToRead); + + MvcResult mvcResult = mockMvc.perform(get(URI_PARAMETERS_GET_PUT + parametersUuid)) + .andExpect(status().isOk()).andReturn(); + String resultAsString = mvcResult.getResponse().getContentAsString(); + VoltageInitParametersInfos receivedParameters = mapper.readValue(resultAsString, new TypeReference<>() { + }); + + assertThat(receivedParameters).recursivelyEquals(parametersToRead); + } + + @Test + public void testUpdate() throws Exception { + + VoltageInitParametersInfos parametersToUpdate = buildParameters(); + + UUID parametersUuid = saveAndRetunId(parametersToUpdate); + + parametersToUpdate = buildParametersUpdate(); + + String parametersToUpdateJson = mapper.writeValueAsString(parametersToUpdate); + + mockMvc.perform(put(URI_PARAMETERS_GET_PUT + parametersUuid).content(parametersToUpdateJson).contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()); + + VoltageInitParametersInfos updatedParameters = parametersRepository.findById(parametersUuid).get().toVoltageInitParametersInfos(); + + assertThat(updatedParameters).recursivelyEquals(parametersToUpdate); + } + + @Test + public void testDelete() throws Exception { + + VoltageInitParametersInfos parametersToDelete = buildParameters(); + + UUID parametersUuid = saveAndRetunId(parametersToDelete); + + mockMvc.perform(delete(URI_PARAMETERS_GET_PUT + parametersUuid)).andExpect(status().isOk()).andReturn(); + + List storedParameters = parametersRepository.findAll(); + + assertTrue(storedParameters.isEmpty()); + } + + @Test + public void testGetAll() throws Exception { + VoltageInitParametersInfos parameters1 = buildParameters(); + + VoltageInitParametersInfos parameters2 = buildParametersUpdate(); + + saveAndRetunId(parameters1); + + saveAndRetunId(parameters2); + + MvcResult mvcResult = mockMvc.perform(get(URI_PARAMETERS_BASE)) + .andExpect(status().isOk()).andReturn(); + String resultAsString = mvcResult.getResponse().getContentAsString(); + List receivedParameters = mapper.readValue(resultAsString, new TypeReference<>() { + }); + + assertThat(receivedParameters).hasSize(2); + } + + @Test + public void testDuplicate() throws Exception { + + VoltageInitParametersInfos parametersToCreate = buildParameters(); + String parametersToCreateJson = mapper.writeValueAsString(parametersToCreate); + mockMvc.perform(post(URI_PARAMETERS_BASE).content(parametersToCreateJson).contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()).andReturn(); + VoltageInitParametersInfos createdParameters = parametersRepository.findAll().get(0).toVoltageInitParametersInfos(); + + mockMvc.perform(post(URI_PARAMETERS_BASE) + .param("duplicateFrom", UUID.randomUUID().toString())) + .andExpect(status().isNotFound()); + + mockMvc.perform(post(URI_PARAMETERS_BASE) + .param("duplicateFrom", createdParameters.getUuid().toString())) + .andExpect(status().isOk()); + + VoltageInitParametersInfos duplicatedParameters = parametersRepository.findAll().get(1).toVoltageInitParametersInfos(); + assertThat(duplicatedParameters).recursivelyEquals(createdParameters); + } + + /** Save parameters into the repository and return its UUID. */ + private UUID saveAndRetunId(VoltageInitParametersInfos parametersInfos) { + return parametersRepository.save(parametersInfos.toEntity()).getId(); + } + + private static VoltageInitParametersInfos buildParameters() { + return VoltageInitParametersInfos.builder() + .voltageLimitsDefault(List.of()) + .voltageLimitsModification(List.of()) + .constantQGenerators(List.of(FilterEquipments.builder() + .filterId(UUID.randomUUID()) + .filterName("qgenFilter1") + .build(), FilterEquipments.builder() + .filterId(UUID.randomUUID()) + .filterName("qgenFilter2") + .build())) + .variableTwoWindingsTransformers(List.of(FilterEquipments.builder() + .filterId(UUID.randomUUID()) + .filterName("vtwFilter1") + .build(), FilterEquipments.builder() + .filterId(UUID.randomUUID()) + .filterName("vtwFilter2") + .build())) + .build(); + } + + private static VoltageInitParametersInfos buildParametersUpdate() { + return VoltageInitParametersInfos.builder() + .voltageLimitsModification(List.of(VoltageLimitInfos.builder() + .priority(0) + .lowVoltageLimit(2.0) + .highVoltageLimit(20.0) + .filters(List.of(FilterEquipments.builder() + .filterId(UUID.randomUUID()) + .filterName("filterName") + .build())) + .build())) + .voltageLimitsDefault(List.of(VoltageLimitInfos.builder() + .priority(0) + .lowVoltageLimit(2.0) + .highVoltageLimit(20.0) + .filters(List.of(FilterEquipments.builder() + .filterId(UUID.randomUUID()) + .filterName("filterName") + .build())) + .build())) + .variableShuntCompensators(List.of(FilterEquipments.builder() + .filterId(UUID.randomUUID()) + .filterName("vscFilter1") + .build())) + .variableTwoWindingsTransformers(List.of(FilterEquipments.builder() + .filterId(UUID.randomUUID()) + .filterName("vtwFilter1Modified") + .build(), FilterEquipments.builder() + .filterId(UUID.randomUUID()) + .filterName("vtwFilter2Modified") + .build())) + .build(); + } +} diff --git a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java b/src/test/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersTest.java similarity index 51% rename from src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java rename to src/test/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersTest.java index 5f7af518..558d5d8c 100644 --- a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java +++ b/src/test/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersTest.java @@ -4,10 +4,8 @@ * 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.voltageinit.server; +package org.gridsuite.voltageinit.server.service.parameters; -import com.fasterxml.jackson.core.type.TypeReference; -import com.fasterxml.jackson.databind.DeserializationFeature; import com.fasterxml.jackson.databind.ObjectMapper; import com.powsybl.iidm.network.IdentifiableType; import com.powsybl.iidm.network.Network; @@ -24,34 +22,29 @@ import org.assertj.core.api.ListAssert; import org.gridsuite.voltageinit.server.dto.parameters.FilterEquipments; import org.gridsuite.voltageinit.server.dto.parameters.IdentifiableAttributes; -import org.gridsuite.voltageinit.server.dto.parameters.VoltageInitParametersInfos; -import org.gridsuite.voltageinit.server.dto.parameters.VoltageLimitInfos; import org.gridsuite.voltageinit.server.entities.parameters.FilterEquipmentsEmbeddable; import org.gridsuite.voltageinit.server.entities.parameters.VoltageInitParametersEntity; import org.gridsuite.voltageinit.server.entities.parameters.VoltageLimitEntity; -import org.gridsuite.voltageinit.server.repository.parameters.VoltageInitParametersRepository; import org.gridsuite.voltageinit.server.service.VoltageInitRunContext; -import org.gridsuite.voltageinit.server.service.parameters.FilterService; -import org.gridsuite.voltageinit.server.service.parameters.VoltageInitParametersService; import org.gridsuite.voltageinit.server.util.VoltageLimitParameterType; import org.gridsuite.voltageinit.utils.TestUtils; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.junit.jupiter.MockitoExtension; import org.skyscreamer.jsonassert.Customization; import org.skyscreamer.jsonassert.JSONAssert; import org.skyscreamer.jsonassert.JSONCompareMode; import org.skyscreamer.jsonassert.comparator.CustomComparator; import org.skyscreamer.jsonassert.comparator.JSONComparator; import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc; +import org.springframework.boot.test.autoconfigure.orm.jpa.AutoConfigureTestEntityManager; +import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.boot.test.mock.mockito.MockBean; -import org.springframework.http.MediaType; import org.springframework.test.annotation.DirtiesContext; -import org.springframework.test.annotation.DirtiesContext.ClassMode; -import org.springframework.test.web.servlet.MockMvc; -import org.springframework.test.web.servlet.MvcResult; +import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.annotation.Transactional; import java.util.List; @@ -60,26 +53,18 @@ import java.util.function.Consumer; import java.util.stream.Stream; -import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.*; import static org.assertj.core.condition.NestableCondition.nestable; import static org.assertj.core.condition.VerboseCondition.verboseCondition; -import static org.gridsuite.voltageinit.utils.assertions.Assertions.assertThat; import static org.mockito.BDDMockito.given; -import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*; -import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; -/** - * @author Ayoub LABIDI - */ +@ExtendWith({ MockitoExtension.class }) @SpringBootTest -@DirtiesContext(classMode = ClassMode.BEFORE_EACH_TEST_METHOD) -@AutoConfigureMockMvc -@Transactional +@DirtiesContext +@AutoConfigureTestEntityManager +@Transactional(propagation = Propagation.REQUIRES_NEW) @Slf4j class VoltageInitParametersTest { - private static final String URI_PARAMETERS_BASE = "/v1/parameters"; - private static final String URI_PARAMETERS_GET_PUT = URI_PARAMETERS_BASE + "/"; - private static final UUID NETWORK_UUID = UUID.fromString("7928181c-7977-4592-ba19-88027e4254e4"); private static final String VARIANT_ID_1 = "variant_1"; private static final UUID FILTER_UUID_1 = UUID.fromString("1a3d23a6-7a4c-11ee-b962-0242ac120002"); @@ -88,15 +73,9 @@ class VoltageInitParametersTest { private static final String FILTER_2 = "FILTER_2"; private static final UUID REPORT_UUID = UUID.fromString("00000000-0000-0000-0000-000000000000"); - private static final VoltageLimitEntity VOLTAGE_LIMIT = new VoltageLimitEntity(UUID.randomUUID(), 5., 10., 0, VoltageLimitParameterType.DEFAULT, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); - private static final VoltageLimitEntity VOLTAGE_LIMIT_2 = new VoltageLimitEntity(UUID.randomUUID(), 44., 88., 1, VoltageLimitParameterType.DEFAULT, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_2, FILTER_2))); - private static final VoltageLimitEntity VOLTAGE_LIMIT_3 = new VoltageLimitEntity(UUID.randomUUID(), -1., -2., 0, VoltageLimitParameterType.MODIFICATION, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); - private static final VoltageLimitEntity VOLTAGE_LIMIT_4 = new VoltageLimitEntity(UUID.randomUUID(), -20.0, 10.0, 0, VoltageLimitParameterType.MODIFICATION, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); - private static final VoltageLimitEntity VOLTAGE_LIMIT_5 = new VoltageLimitEntity(UUID.randomUUID(), 10.0, 10.0, 0, VoltageLimitParameterType.DEFAULT, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); - private static final JSONComparator REPORTER_COMPARATOR = new CustomComparator(JSONCompareMode.STRICT, - // ignore field having uuid changing each run - new Customization("reportTree.subReporters[*].taskValues.parameters_id.value", (o1, o2) -> (o1 == null) == (o2 == null)) + // ignore field having uuid changing each run + new Customization("reportTree.subReporters[*].taskValues.parameters_id.value", (o1, o2) -> (o1 == null) == (o2 == null)) ); private Network network; @@ -105,14 +84,11 @@ class VoltageInitParametersTest { private VoltageInitParametersService voltageInitParametersService; @Autowired - private MockMvc mockMvc; + private TestEntityManager entityManager; @Autowired private ObjectMapper mapper; - @Autowired - private VoltageInitParametersRepository parametersRepository; - @MockBean private NetworkStoreService networkStoreService; @@ -121,8 +97,6 @@ class VoltageInitParametersTest { @BeforeEach public void setup() { - mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES); - network = EurostagTutorialExample1Factory.create(new NetworkFactoryImpl()); network.getVariantManager().cloneVariant(VariantManagerConstants.INITIAL_VARIANT_ID, VARIANT_ID_1); network.getVariantManager().setWorkingVariant(VARIANT_ID_1); @@ -145,161 +119,6 @@ public void setup() { )); } - @Test - void testCreate() throws Exception { - VoltageInitParametersInfos parametersToCreate = buildParameters(); - String parametersToCreateJson = mapper.writeValueAsString(parametersToCreate); - - mockMvc.perform(post(URI_PARAMETERS_BASE).content(parametersToCreateJson).contentType(MediaType.APPLICATION_JSON)) - .andExpect(status().isOk()).andReturn(); - - VoltageInitParametersInfos createdParameters = parametersRepository.findAll().get(0).toVoltageInitParametersInfos(); - - assertThat(createdParameters).recursivelyEquals(parametersToCreate); - } - - @Test - void testRead() throws Exception { - VoltageInitParametersInfos parametersToRead = buildParameters(); - - UUID parametersUuid = saveAndReturnId(parametersToRead); - - MvcResult mvcResult = mockMvc.perform(get(URI_PARAMETERS_GET_PUT + parametersUuid)) - .andExpect(status().isOk()).andReturn(); - String resultAsString = mvcResult.getResponse().getContentAsString(); - VoltageInitParametersInfos receivedParameters = mapper.readValue(resultAsString, new TypeReference<>() { - }); - - assertThat(receivedParameters).recursivelyEquals(parametersToRead); - } - - @Test - void testUpdate() throws Exception { - VoltageInitParametersInfos parametersToUpdate = buildParameters(); - - UUID parametersUuid = saveAndReturnId(parametersToUpdate); - - parametersToUpdate = buildParametersUpdate(); - - String parametersToUpdateJson = mapper.writeValueAsString(parametersToUpdate); - - mockMvc.perform(put(URI_PARAMETERS_GET_PUT + parametersUuid).content(parametersToUpdateJson).contentType(MediaType.APPLICATION_JSON)) - .andExpect(status().isOk()); - - VoltageInitParametersInfos updatedParameters = parametersRepository.findById(parametersUuid).get().toVoltageInitParametersInfos(); - - assertThat(updatedParameters).recursivelyEquals(parametersToUpdate); - } - - @Test - void testDelete() throws Exception { - VoltageInitParametersInfos parametersToDelete = buildParameters(); - - UUID parametersUuid = saveAndReturnId(parametersToDelete); - - mockMvc.perform(delete(URI_PARAMETERS_GET_PUT + parametersUuid)).andExpect(status().isOk()).andReturn(); - assertThat(parametersRepository.count()).as("parameters repository items count").isZero(); - } - - @Test - void testGetAll() throws Exception { - VoltageInitParametersInfos parameters1 = buildParameters(); - - VoltageInitParametersInfos parameters2 = buildParametersUpdate(); - - saveAndReturnId(parameters1); - - saveAndReturnId(parameters2); - - MvcResult mvcResult = mockMvc.perform(get(URI_PARAMETERS_BASE)) - .andExpect(status().isOk()).andReturn(); - String resultAsString = mvcResult.getResponse().getContentAsString(); - List receivedParameters = mapper.readValue(resultAsString, new TypeReference<>() { - }); - - assertThat(receivedParameters).hasSize(2); - } - - @Test - void testDuplicate() throws Exception { - VoltageInitParametersInfos parametersToCreate = buildParameters(); - String parametersToCreateJson = mapper.writeValueAsString(parametersToCreate); - mockMvc.perform(post(URI_PARAMETERS_BASE).content(parametersToCreateJson).contentType(MediaType.APPLICATION_JSON)) - .andExpect(status().isOk()).andReturn(); - VoltageInitParametersInfos createdParameters = parametersRepository.findAll().get(0).toVoltageInitParametersInfos(); - - mockMvc.perform(post(URI_PARAMETERS_BASE) - .param("duplicateFrom", UUID.randomUUID().toString())) - .andExpect(status().isNotFound()); - - mockMvc.perform(post(URI_PARAMETERS_BASE) - .param("duplicateFrom", createdParameters.getUuid().toString())) - .andExpect(status().isOk()); - - VoltageInitParametersInfos duplicatedParameters = parametersRepository.findAll().get(1).toVoltageInitParametersInfos(); - assertThat(duplicatedParameters).recursivelyEquals(createdParameters); - } - - /** Save parameters into the repository and return its UUID. */ - private UUID saveAndReturnId(VoltageInitParametersInfos parametersInfos) { - return parametersRepository.save(parametersInfos.toEntity()).getId(); - } - - private static VoltageInitParametersInfos buildParameters() { - return VoltageInitParametersInfos.builder() - .voltageLimitsDefault(List.of()) - .voltageLimitsModification(List.of()) - .constantQGenerators(List.of(FilterEquipments.builder() - .filterId(UUID.randomUUID()) - .filterName("qgenFilter1") - .build(), FilterEquipments.builder() - .filterId(UUID.randomUUID()) - .filterName("qgenFilter2") - .build())) - .variableTwoWindingsTransformers(List.of(FilterEquipments.builder() - .filterId(UUID.randomUUID()) - .filterName("vtwFilter1") - .build(), FilterEquipments.builder() - .filterId(UUID.randomUUID()) - .filterName("vtwFilter2") - .build())) - .build(); - } - - private static VoltageInitParametersInfos buildParametersUpdate() { - return VoltageInitParametersInfos.builder() - .voltageLimitsModification(List.of(VoltageLimitInfos.builder() - .priority(0) - .lowVoltageLimit(2.0) - .highVoltageLimit(20.0) - .filters(List.of(FilterEquipments.builder() - .filterId(UUID.randomUUID()) - .filterName("filterName") - .build())) - .build())) - .voltageLimitsDefault(List.of(VoltageLimitInfos.builder() - .priority(0) - .lowVoltageLimit(2.0) - .highVoltageLimit(20.0) - .filters(List.of(FilterEquipments.builder() - .filterId(UUID.randomUUID()) - .filterName("filterName") - .build())) - .build())) - .variableShuntCompensators(List.of(FilterEquipments.builder() - .filterId(UUID.randomUUID()) - .filterName("vscFilter1") - .build())) - .variableTwoWindingsTransformers(List.of(FilterEquipments.builder() - .filterId(UUID.randomUUID()) - .filterName("vtwFilter1Modified") - .build(), FilterEquipments.builder() - .filterId(UUID.randomUUID()) - .filterName("vtwFilter2Modified") - .build())) - .build(); - } - private static Consumer assertVoltageLimitOverride(final String levelId, final VoltageLimitType limitType) { return assertVoltageLimitOverride(levelId, limitType, null); } @@ -320,8 +139,8 @@ private static Consumer assertVoltageLimitOverride(final S } private ListAssert testsBuildSpecificVoltageLimitsCommon(List voltageLimits, String reportFilename) throws Exception { - final VoltageInitParametersEntity voltageInitParameters = parametersRepository.save( - new VoltageInitParametersEntity(UUID.randomUUID(), null, "", voltageLimits, null, null, null) + final VoltageInitParametersEntity voltageInitParameters = entityManager.persistFlushFind( + new VoltageInitParametersEntity(null, null, "", voltageLimits, null, null, null) ); final VoltageInitRunContext context = new VoltageInitRunContext(NETWORK_UUID, VARIANT_ID_1, null, REPORT_UUID, null, "", "", voltageInitParameters.getId()); final OpenReacParameters openReacParameters = voltageInitParametersService.buildOpenReacParameters(context, network); @@ -333,7 +152,9 @@ private ListAssert testsBuildSpecificVoltageLimitsCommon(L @DisplayName("buildSpecificVoltageLimits: No voltage limit modification") @Test void testsBuildSpecificVoltageLimitsSimple() throws Exception { - testsBuildSpecificVoltageLimitsCommon(List.of(VOLTAGE_LIMIT, VOLTAGE_LIMIT_2), "reporter_buildOpenReacParameters.json") + final VoltageLimitEntity voltageLimit = new VoltageLimitEntity(null, 5., 10., 0, VoltageLimitParameterType.DEFAULT, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); + final VoltageLimitEntity voltageLimit2 = new VoltageLimitEntity(null, 44., 88., 1, VoltageLimitParameterType.DEFAULT, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_2, FILTER_2))); + testsBuildSpecificVoltageLimitsCommon(List.of(voltageLimit, voltageLimit2), "reporter_buildOpenReacParameters.json") .hasSize(4) //No override should be relative since there is no voltage limit modification .noneMatch(VoltageLimitOverride::isRelative) @@ -350,8 +171,11 @@ void testsBuildSpecificVoltageLimitsSimple() throws Exception { @DisplayName("buildSpecificVoltageLimits: With voltage limit modifications") @Test void testsBuildSpecificVoltageLimitsWithLimitModifications() throws Exception { + final VoltageLimitEntity voltageLimit = new VoltageLimitEntity(null, 5., 10., 0, VoltageLimitParameterType.DEFAULT, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); + final VoltageLimitEntity voltageLimit2 = new VoltageLimitEntity(null, 44., 88., 1, VoltageLimitParameterType.DEFAULT, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_2, FILTER_2))); + final VoltageLimitEntity voltageLimit3 = new VoltageLimitEntity(null, -1., -2., 0, VoltageLimitParameterType.MODIFICATION, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); //We now add limit modifications in additions to defaults settings - testsBuildSpecificVoltageLimitsCommon(List.of(VOLTAGE_LIMIT, VOLTAGE_LIMIT_2, VOLTAGE_LIMIT_3), "reporter_buildOpenReacParameters_withLimitModifications.json") + testsBuildSpecificVoltageLimitsCommon(List.of(voltageLimit, voltageLimit2, voltageLimit3), "reporter_buildOpenReacParameters_withLimitModifications.json") //Limits that weren't impacted by default settings are now impacted by modification settings .hasSize(8) //There should (not?) be relative overrides since voltage limit modification are applied @@ -367,8 +191,9 @@ void testsBuildSpecificVoltageLimitsWithLimitModifications() throws Exception { @DisplayName("buildSpecificVoltageLimits: Case relative true overrides") @Test void testsBuildSpecificVoltageLimitsCaseRelativeTrue() throws Exception { + final VoltageLimitEntity voltageLimit4 = new VoltageLimitEntity(null, -20.0, 10.0, 0, VoltageLimitParameterType.MODIFICATION, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); // We need to check for the case of relative = true with the modification less than 0 => the new low voltage limit = low voltage limit * -1 - testsBuildSpecificVoltageLimitsCommon(List.of(VOLTAGE_LIMIT_4), "reporter_buildOpenReacParameters_caseRelativeTrue.json") + testsBuildSpecificVoltageLimitsCommon(List.of(voltageLimit4), "reporter_buildOpenReacParameters_caseRelativeTrue.json") .hasSize(4) // isRelative: There should have relative true overrides since voltage limit modification are applied for VLGEN // getLimit: The low voltage limit must be impacted by the modification of the value @@ -376,11 +201,13 @@ void testsBuildSpecificVoltageLimitsCaseRelativeTrue() throws Exception { //note: VoltageLimitOverride implement equals() correctly, so we can use it } - @DisplayName("buildSpecificVoltageLimits: No voltage limit modification") + @DisplayName("buildSpecificVoltageLimits: Case relative false overrides") @Test void testsBuildSpecificVoltageLimitsCaseRelativeFalse() throws Exception { + final VoltageLimitEntity voltageLimit4 = new VoltageLimitEntity(null, -20.0, 10.0, 0, VoltageLimitParameterType.MODIFICATION, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); + final VoltageLimitEntity voltageLimit5 = new VoltageLimitEntity(null, 10.0, 10.0, 0, VoltageLimitParameterType.DEFAULT, List.of(new FilterEquipmentsEmbeddable(FILTER_UUID_1, FILTER_1))); // We need to check for the case of relative = false with the modification less than 0 => the new low voltage limit = 0 - testsBuildSpecificVoltageLimitsCommon(List.of(VOLTAGE_LIMIT_4, VOLTAGE_LIMIT_5), "reporter_buildOpenReacParameters_caseRelativeFalse.json") + testsBuildSpecificVoltageLimitsCommon(List.of(voltageLimit4, voltageLimit5), "reporter_buildOpenReacParameters_caseRelativeFalse.json") .hasSize(8) // isRelative: There should have relative false overrides since voltage limit modification are applied for VLHV1 // getLimit: The low voltage limit must be impacted by the modification of the value diff --git a/src/test/java/org/gridsuite/voltageinit/utils/assertions/ReflectiveRepresentation.java b/src/test/java/org/gridsuite/voltageinit/utils/assertions/ReflectiveRepresentation.java index 028f7c0b..eb2be624 100644 --- a/src/test/java/org/gridsuite/voltageinit/utils/assertions/ReflectiveRepresentation.java +++ b/src/test/java/org/gridsuite/voltageinit/utils/assertions/ReflectiveRepresentation.java @@ -2,11 +2,15 @@ import com.google.auto.service.AutoService; import lombok.extern.slf4j.Slf4j; +import org.apache.commons.lang3.builder.RecursiveToStringStyle; import org.apache.commons.lang3.builder.ToStringBuilder; +import org.apache.commons.lang3.builder.ToStringStyle; import org.assertj.core.presentation.Representation; import org.assertj.core.presentation.StandardRepresentation; import org.jetbrains.annotations.NotNull; +import java.lang.reflect.InaccessibleObjectException; + /** * AssertJ {@link Representation} for types having no {@link Object#toString() toString()} implemented */ @@ -20,7 +24,12 @@ public class ReflectiveRepresentation extends StandardRepresentation { protected String fallbackToStringOf(@NotNull final Object object) { try { if (Object.class.equals(object.getClass().getMethod("toString").getDeclaringClass())) { - return ToStringBuilder.reflectionToString(object); + try { + return ToStringBuilder.reflectionToString(object, new RecursiveToStringStyle()); + } catch (final InaccessibleObjectException e) { + //unnamed module haven't opens to java.base/* + return ToStringBuilder.reflectionToString(object, ToStringStyle.DEFAULT_STYLE); + } } } catch (NoSuchMethodException e) { log.warn("Error while analysing object class", e); From e0ec9086574687bcfe639d2b5b4942c7fc157844 Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Wed, 27 Mar 2024 20:24:46 +0100 Subject: [PATCH 19/53] review clean PR --- pom.xml | 10 +++++++++ .../entities/VoltageInitResultEntity.java | 21 +++++++++++++------ .../VoltageInitResultRepository.java | 9 ++++++-- .../server/service/VoltageInitRunContext.java | 8 +++++++ .../server/service/VoltageInitService.java | 1 + .../VoltageInitParametersService.java | 2 ++ 6 files changed, 43 insertions(+), 8 deletions(-) diff --git a/pom.xml b/pom.xml index 3d7db5ea..06e0da31 100644 --- a/pom.xml +++ b/pom.xml @@ -189,11 +189,21 @@ powsybl-iidm-test test + + com.squareup.okhttp3 + okhttp + test + com.squareup.okhttp3 mockwebserver test + + junit + junit + test + org.assertj assertj-guava diff --git a/src/main/java/org/gridsuite/voltageinit/server/entities/VoltageInitResultEntity.java b/src/main/java/org/gridsuite/voltageinit/server/entities/VoltageInitResultEntity.java index 52603341..4d369d14 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/entities/VoltageInitResultEntity.java +++ b/src/main/java/org/gridsuite/voltageinit/server/entities/VoltageInitResultEntity.java @@ -6,17 +6,26 @@ */ package org.gridsuite.voltageinit.server.entities; -import jakarta.persistence.*; +import java.util.List; +import java.util.Map; +import java.util.UUID; + +import java.time.ZonedDateTime; + +import jakarta.persistence.CollectionTable; +import jakarta.persistence.Column; +import jakarta.persistence.ElementCollection; +import jakarta.persistence.Entity; +import jakarta.persistence.ForeignKey; +import jakarta.persistence.Id; +import jakarta.persistence.Index; +import jakarta.persistence.Table; + import lombok.AllArgsConstructor; import lombok.Getter; import lombok.NoArgsConstructor; import lombok.Setter; -import java.time.ZonedDateTime; -import java.util.List; -import java.util.Map; -import java.util.UUID; - /** * @author Ayoub LABIDI */ diff --git a/src/main/java/org/gridsuite/voltageinit/server/repository/VoltageInitResultRepository.java b/src/main/java/org/gridsuite/voltageinit/server/repository/VoltageInitResultRepository.java index 701866e6..88bea8ab 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/repository/VoltageInitResultRepository.java +++ b/src/main/java/org/gridsuite/voltageinit/server/repository/VoltageInitResultRepository.java @@ -7,7 +7,6 @@ package org.gridsuite.voltageinit.server.repository; import com.powsybl.iidm.network.Bus; -import com.powsybl.openreac.parameters.output.OpenReacResult; import org.gridsuite.voltageinit.server.entities.BusVoltageEmbeddable; import org.gridsuite.voltageinit.server.entities.GlobalStatusEntity; import org.gridsuite.voltageinit.server.entities.ReactiveSlackEmbeddable; @@ -16,8 +15,14 @@ import org.springframework.stereotype.Repository; import org.springframework.transaction.annotation.Transactional; +import com.powsybl.openreac.parameters.output.OpenReacResult; + import java.time.ZonedDateTime; -import java.util.*; +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; /** diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitRunContext.java b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitRunContext.java index d29d5516..cd6da2f6 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitRunContext.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitRunContext.java @@ -23,13 +23,21 @@ public class VoltageInitRunContext { private static final String VOLTAGE_INIT_TYPE_REPORT = "VoltageInit"; private final UUID networkUuid; + private final String variantId; + private final String receiver; + private final UUID reportUuid; + private final String reporterId; + private final String reportType; + private final String userId; + private final UUID parametersUuid; + private final Map voltageLevelsIdsRestricted; private final Reporter rootReporter; diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitService.java b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitService.java index 86724023..5332dc73 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitService.java @@ -7,6 +7,7 @@ package org.gridsuite.voltageinit.server.service; import com.powsybl.network.store.client.NetworkStoreService; + import org.gridsuite.voltageinit.server.dto.BusVoltage; import org.gridsuite.voltageinit.server.dto.ReactiveSlack; import org.gridsuite.voltageinit.server.dto.VoltageInitResult; diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index 9f3b09a5..e0350895 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -39,9 +39,11 @@ @Service public class VoltageInitParametersService { + private static final Logger LOGGER = LoggerFactory.getLogger(VoltageInitParametersService.class); private final FilterService filterService; + private final VoltageInitParametersRepository voltageInitParametersRepository; public VoltageInitParametersService(VoltageInitParametersRepository voltageInitParametersRepository, FilterService filterService) { From a319191e63aaa1abc2bdf5dedaf3355d81fbc75e Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Wed, 27 Mar 2024 21:14:54 +0100 Subject: [PATCH 20/53] review minimify diff with main branch --- .../VoltageInitParametersService.java | 124 ++++++++++-------- 1 file changed, 68 insertions(+), 56 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index e0350895..de7edceb 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -86,14 +86,11 @@ private Map resolveVoltageLevelLimits(VoltageInitRun Map voltageLevelLimits = new HashMap<>(); //each voltage level is associated to a voltage limit setting //if a voltage level is resolved by multiple filters the highest priority setting will be kept - voltageLimits.forEach(voltageLimit -> filterService.exportFilters( - voltageLimit.getFilters().stream().map(FilterEquipmentsEmbeddable::getFilterId).toList(), - context.getNetworkUuid(), context.getVariantId() - ).stream() - .map(FilterEquipments::getIdentifiableAttributes) - .flatMap(List::stream) - .map(IdentifiableAttributes::getId) - .forEach(voltageLevelsId -> voltageLevelLimits.put(voltageLevelsId, voltageLimit)) + voltageLimits.stream().forEach(voltageLimit -> + filterService.exportFilters(voltageLimit.getFilters().stream().map(FilterEquipmentsEmbeddable::getFilterId).toList(), context.getNetworkUuid(), context.getVariantId()) + .forEach(filterEquipment -> filterEquipment.getIdentifiableAttributes().stream().map(IdentifiableAttributes::getId) + .forEach(voltageLevelsId -> voltageLevelLimits.put(voltageLevelsId, voltageLimit)) + ) ); return voltageLevelLimits; } @@ -103,29 +100,35 @@ private static void fillSpecificVoltageLimits(List specifi Map voltageLevelDefaultLimits, VoltageLevel voltageLevel, Map voltageLevelsIdsRestricted) { - setLowVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, voltageLevel, voltageLevelsIdsRestricted); - setHighVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, voltageLevel); + boolean isLowVoltageLimitModificationSet = voltageLevelModificationLimits.containsKey(voltageLevel.getId()) && voltageLevelModificationLimits.get(voltageLevel.getId()).getLowVoltageLimit() != null; + boolean isHighVoltageLimitModificationSet = voltageLevelModificationLimits.containsKey(voltageLevel.getId()) && voltageLevelModificationLimits.get(voltageLevel.getId()).getHighVoltageLimit() != null; + boolean isLowVoltageLimitDefaultSet = voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) && voltageLevelDefaultLimits.get(voltageLevel.getId()).getLowVoltageLimit() != null; + boolean isHighVoltageLimitDefaultSet = voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) && voltageLevelDefaultLimits.get(voltageLevel.getId()).getHighVoltageLimit() != null; + + setLowVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isLowVoltageLimitModificationSet, isLowVoltageLimitDefaultSet, voltageLevel, voltageLevelsIdsRestricted); + setHighVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isHighVoltageLimitModificationSet, isHighVoltageLimitDefaultSet, voltageLevel); } private static void setLowVoltageLimit(List specificVoltageLimits, Map voltageLevelModificationLimits, Map voltageLevelDefaultLimits, + boolean isLowVoltageLimitModificationSet, + boolean isLowVoltageLimitDefaultSet, VoltageLevel voltageLevel, Map voltageLevelsIdsRestricted) { - boolean isLowVoltageLimitModificationSet = voltageLevelModificationLimits.containsKey(voltageLevel.getId()) && voltageLevelModificationLimits.get(voltageLevel.getId()).getLowVoltageLimit() != null; - boolean isLowVoltageLimitDefaultSet = voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) && voltageLevelDefaultLimits.get(voltageLevel.getId()).getLowVoltageLimit() != null; double newLowVoltageLimit; - if (!Double.isNaN(voltageLevel.getLowVoltageLimit()) && isLowVoltageLimitModificationSet) { + double lowVoltageLimit = voltageLevel.getLowVoltageLimit(); + if (!Double.isNaN(lowVoltageLimit) && isLowVoltageLimitModificationSet) { double lowVoltageLimitModification = voltageLevelModificationLimits.get(voltageLevel.getId()).getLowVoltageLimit(); - if (voltageLevel.getLowVoltageLimit() + lowVoltageLimitModification < 0) { - newLowVoltageLimit = voltageLevel.getLowVoltageLimit() * -1; + if (lowVoltageLimit + lowVoltageLimitModification < 0) { + newLowVoltageLimit = lowVoltageLimit * -1; voltageLevelsIdsRestricted.put(voltageLevel.getId(), newLowVoltageLimit); } else { newLowVoltageLimit = lowVoltageLimitModification; } specificVoltageLimits.add(new VoltageLimitOverride(voltageLevel.getId(), VoltageLimitType.LOW_VOLTAGE_LIMIT, true, newLowVoltageLimit)); - } else if (Double.isNaN(voltageLevel.getLowVoltageLimit()) && isLowVoltageLimitDefaultSet) { + } else if (Double.isNaN(lowVoltageLimit) && isLowVoltageLimitDefaultSet) { double voltageLimit = voltageLevelDefaultLimits.get(voltageLevel.getId()).getLowVoltageLimit() + (isLowVoltageLimitModificationSet ? voltageLevelModificationLimits.get(voltageLevel.getId()).getLowVoltageLimit() : 0.); if (voltageLimit < 0) { newLowVoltageLimit = 0.0; @@ -140,9 +143,9 @@ private static void setLowVoltageLimit(List specificVoltag private static void setHighVoltageLimit(List specificVoltageLimits, Map voltageLevelModificationLimits, Map voltageLevelDefaultLimits, + boolean isHighVoltageLimitModificationSet, + boolean isHighVoltageLimitDefaultSet, VoltageLevel voltageLevel) { - boolean isHighVoltageLimitModificationSet = voltageLevelModificationLimits.containsKey(voltageLevel.getId()) && voltageLevelModificationLimits.get(voltageLevel.getId()).getHighVoltageLimit() != null; - boolean isHighVoltageLimitDefaultSet = voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) && voltageLevelDefaultLimits.get(voltageLevel.getId()).getHighVoltageLimit() != null; if (!Double.isNaN(voltageLevel.getHighVoltageLimit()) && isHighVoltageLimitModificationSet) { specificVoltageLimits.add(new VoltageLimitOverride(voltageLevel.getId(), VoltageLimitType.HIGH_VOLTAGE_LIMIT, true, voltageLevelModificationLimits.get(voltageLevel.getId()).getHighVoltageLimit())); } else if (Double.isNaN(voltageLevel.getHighVoltageLimit()) && isHighVoltageLimitDefaultSet) { @@ -153,48 +156,57 @@ private static void setHighVoltageLimit(List specificVolta @Transactional(readOnly = true) public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, Network network) { final long startTime = System.nanoTime(); - final OpenReacParameters parameters = new OpenReacParameters(); final Reporter reporter = context.getRootReporter().createSubReporter("OpenReactParameters", "OpenReact parameters", Map.of( "parameters_id", new TypedValue(Objects.toString(context.getParametersUuid()), "ID") )); - Optional.ofNullable(context.getParametersUuid()) - .flatMap(voltageInitParametersRepository::findById) - .ifPresentOrElse(voltageInitParameters -> { - if (voltageInitParameters.getVoltageLimits() != null) { - final Map voltageLevelDefaultLimits = resolveVoltageLevelLimits(context, voltageInitParameters.getVoltageLimits() - .stream() - .filter(voltageLimit -> VoltageLimitParameterType.DEFAULT.equals(voltageLimit.getVoltageLimitParameterType())) - .toList()); - final Map voltageLevelModificationLimits = resolveVoltageLevelLimits(context, voltageInitParameters.getVoltageLimits() - .stream() - .filter(voltageLimit -> VoltageLimitParameterType.MODIFICATION.equals(voltageLimit.getVoltageLimitParameterType())) - .toList()); - List specificVoltageLimits = new LinkedList<>(); - network.getVoltageLevelStream() - .forEach(voltageLevel -> fillSpecificVoltageLimits(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, voltageLevel, context.getVoltageLevelsIdsRestricted())); - parameters.addSpecificVoltageLimits(specificVoltageLimits); - if (!context.getVoltageLevelsIdsRestricted().isEmpty()) { - reporter.report(Report.builder() - .withKey("restrictedVoltageLevels") - .withDefaultMessage("The modifications to the low limits for certain voltage levels have been restricted to avoid negative voltage limits: ${joinedVoltageLevelsIds}") - .withValue("joinedVoltageLevelsIds", context.getVoltageLevelsIdsRestricted() - .entrySet() - .stream() - .map(entry -> entry.getKey() + "=" + entry.getValue()) - .collect(Collectors.joining(", "))) - .withSeverity(TypedValue.WARN_SEVERITY) - .build()); - } - } - parameters.addConstantQGenerators(toEquipmentIdsList(context.getNetworkUuid(), context.getVariantId(), voltageInitParameters.getConstantQGenerators())) - .addVariableTwoWindingsTransformers(toEquipmentIdsList(context.getNetworkUuid(), context.getVariantId(), voltageInitParameters.getVariableTwoWindingsTransformers())) - .addVariableShuntCompensators(toEquipmentIdsList(context.getNetworkUuid(), context.getVariantId(), voltageInitParameters.getVariableShuntCompensators())); - }, () -> reporter.report(Report.builder() - .withKey("noParameters") - .withDefaultMessage("No parameters were found for this analysis: using default parameters.") - .withSeverity(TypedValue.TRACE_SEVERITY) - .build())); + Optional voltageInitParametersEntity = Optional.empty(); + if (context.getParametersUuid() != null) { + voltageInitParametersEntity = voltageInitParametersRepository.findById(context.getParametersUuid()); + } + + OpenReacParameters parameters = new OpenReacParameters(); + List specificVoltageLimits = new ArrayList<>(); + List constantQGenerators = new ArrayList<>(); + List variableTwoWindingsTransformers = new ArrayList<>(); + List variableShuntCompensators = new ArrayList<>(); + + voltageInitParametersEntity.ifPresent(voltageInitParameters -> { + if (voltageInitParameters.getVoltageLimits() != null) { + Map voltageLevelDefaultLimits = resolveVoltageLevelLimits(context, voltageInitParameters.getVoltageLimits().stream() + .filter(voltageLimit -> VoltageLimitParameterType.DEFAULT.equals(voltageLimit.getVoltageLimitParameterType())) + .toList()); + + Map voltageLevelModificationLimits = resolveVoltageLevelLimits(context, voltageInitParameters.getVoltageLimits().stream() + .filter(voltageLimit -> VoltageLimitParameterType.MODIFICATION.equals(voltageLimit.getVoltageLimitParameterType())) + .toList()); + + network.getVoltageLevelStream() + .filter(voltageLevel -> voltageLevelDefaultLimits.keySet().contains(voltageLevel.getId()) || voltageLevelModificationLimits.keySet().contains(voltageLevel.getId())) + .forEach(voltageLevel -> fillSpecificVoltageLimits(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, voltageLevel, context.getVoltageLevelsIdsRestricted())); + + if (!context.getVoltageLevelsIdsRestricted().isEmpty()) { + reporter.report(Report.builder() + .withKey("restrictedVoltageLevels") + .withDefaultMessage("The modifications to the low limits for certain voltage levels have been restricted to avoid negative voltage limits: ${joinedVoltageLevelsIds}") + .withValue("joinedVoltageLevelsIds", context.getVoltageLevelsIdsRestricted() + .entrySet() + .stream() + .map(entry -> entry.getKey() + "=" + entry.getValue()) + .collect(Collectors.joining(", "))) + .withSeverity(TypedValue.WARN_SEVERITY) + .build()); + } + } + + constantQGenerators.addAll(toEquipmentIdsList(context.getNetworkUuid(), context.getVariantId(), voltageInitParameters.getConstantQGenerators())); + variableTwoWindingsTransformers.addAll(toEquipmentIdsList(context.getNetworkUuid(), context.getVariantId(), voltageInitParameters.getVariableTwoWindingsTransformers())); + variableShuntCompensators.addAll(toEquipmentIdsList(context.getNetworkUuid(), context.getVariantId(), voltageInitParameters.getVariableShuntCompensators())); + }); + parameters.addSpecificVoltageLimits(specificVoltageLimits) + .addConstantQGenerators(constantQGenerators) + .addVariableTwoWindingsTransformers(variableTwoWindingsTransformers) + .addVariableShuntCompensators(variableShuntCompensators); long nbMissingVoltageLimits = 0L; long nbVoltageLimitModifications = 0L; From 81a56458ce1abd2b742d9ec7b6ac43a598e78cbb Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Wed, 3 Apr 2024 10:11:33 +0200 Subject: [PATCH 21/53] Git diff track correct file --- ...st.java => VoltageInitParametersTest.java} | 48 +++++++++---------- ...arametersTest.java => ParametersTest.java} | 2 +- 2 files changed, 25 insertions(+), 25 deletions(-) rename src/test/java/org/gridsuite/voltageinit/server/{VoltageInitParametersControllerTest.java => VoltageInitParametersTest.java} (88%) rename src/test/java/org/gridsuite/voltageinit/server/service/parameters/{VoltageInitParametersTest.java => ParametersTest.java} (99%) diff --git a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersControllerTest.java b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java similarity index 88% rename from src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersControllerTest.java rename to src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java index e47c7da4..a56865f4 100644 --- a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersControllerTest.java +++ b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java @@ -41,7 +41,7 @@ @DirtiesContext @AutoConfigureMockMvc @Transactional -public class VoltageInitParametersControllerTest { +public class VoltageInitParametersTest { private static final String URI_PARAMETERS_BASE = "/v1/parameters"; private static final String URI_PARAMETERS_GET_PUT = URI_PARAMETERS_BASE + "/"; @@ -61,7 +61,7 @@ public void testCreate() throws Exception { String parametersToCreateJson = mapper.writeValueAsString(parametersToCreate); mockMvc.perform(post(URI_PARAMETERS_BASE).content(parametersToCreateJson).contentType(MediaType.APPLICATION_JSON)) - .andExpect(status().isOk()).andReturn(); + .andExpect(status().isOk()).andReturn(); VoltageInitParametersInfos createdParameters = parametersRepository.findAll().get(0).toVoltageInitParametersInfos(); @@ -76,7 +76,7 @@ public void testRead() throws Exception { UUID parametersUuid = saveAndRetunId(parametersToRead); MvcResult mvcResult = mockMvc.perform(get(URI_PARAMETERS_GET_PUT + parametersUuid)) - .andExpect(status().isOk()).andReturn(); + .andExpect(status().isOk()).andReturn(); String resultAsString = mvcResult.getResponse().getContentAsString(); VoltageInitParametersInfos receivedParameters = mapper.readValue(resultAsString, new TypeReference<>() { }); @@ -96,7 +96,7 @@ public void testUpdate() throws Exception { String parametersToUpdateJson = mapper.writeValueAsString(parametersToUpdate); mockMvc.perform(put(URI_PARAMETERS_GET_PUT + parametersUuid).content(parametersToUpdateJson).contentType(MediaType.APPLICATION_JSON)) - .andExpect(status().isOk()); + .andExpect(status().isOk()); VoltageInitParametersInfos updatedParameters = parametersRepository.findById(parametersUuid).get().toVoltageInitParametersInfos(); @@ -128,7 +128,7 @@ public void testGetAll() throws Exception { saveAndRetunId(parameters2); MvcResult mvcResult = mockMvc.perform(get(URI_PARAMETERS_BASE)) - .andExpect(status().isOk()).andReturn(); + .andExpect(status().isOk()).andReturn(); String resultAsString = mvcResult.getResponse().getContentAsString(); List receivedParameters = mapper.readValue(resultAsString, new TypeReference<>() { }); @@ -142,7 +142,7 @@ public void testDuplicate() throws Exception { VoltageInitParametersInfos parametersToCreate = buildParameters(); String parametersToCreateJson = mapper.writeValueAsString(parametersToCreate); mockMvc.perform(post(URI_PARAMETERS_BASE).content(parametersToCreateJson).contentType(MediaType.APPLICATION_JSON)) - .andExpect(status().isOk()).andReturn(); + .andExpect(status().isOk()).andReturn(); VoltageInitParametersInfos createdParameters = parametersRepository.findAll().get(0).toVoltageInitParametersInfos(); mockMvc.perform(post(URI_PARAMETERS_BASE) @@ -167,19 +167,19 @@ private static VoltageInitParametersInfos buildParameters() { .voltageLimitsDefault(List.of()) .voltageLimitsModification(List.of()) .constantQGenerators(List.of(FilterEquipments.builder() - .filterId(UUID.randomUUID()) - .filterName("qgenFilter1") - .build(), FilterEquipments.builder() - .filterId(UUID.randomUUID()) - .filterName("qgenFilter2") - .build())) + .filterId(UUID.randomUUID()) + .filterName("qgenFilter1") + .build(), FilterEquipments.builder() + .filterId(UUID.randomUUID()) + .filterName("qgenFilter2") + .build())) .variableTwoWindingsTransformers(List.of(FilterEquipments.builder() - .filterId(UUID.randomUUID()) - .filterName("vtwFilter1") - .build(), FilterEquipments.builder() - .filterId(UUID.randomUUID()) - .filterName("vtwFilter2") - .build())) + .filterId(UUID.randomUUID()) + .filterName("vtwFilter1") + .build(), FilterEquipments.builder() + .filterId(UUID.randomUUID()) + .filterName("vtwFilter2") + .build())) .build(); } @@ -208,12 +208,12 @@ private static VoltageInitParametersInfos buildParametersUpdate() { .filterName("vscFilter1") .build())) .variableTwoWindingsTransformers(List.of(FilterEquipments.builder() - .filterId(UUID.randomUUID()) - .filterName("vtwFilter1Modified") - .build(), FilterEquipments.builder() - .filterId(UUID.randomUUID()) - .filterName("vtwFilter2Modified") - .build())) + .filterId(UUID.randomUUID()) + .filterName("vtwFilter1Modified") + .build(), FilterEquipments.builder() + .filterId(UUID.randomUUID()) + .filterName("vtwFilter2Modified") + .build())) .build(); } } diff --git a/src/test/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersTest.java b/src/test/java/org/gridsuite/voltageinit/server/service/parameters/ParametersTest.java similarity index 99% rename from src/test/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersTest.java rename to src/test/java/org/gridsuite/voltageinit/server/service/parameters/ParametersTest.java index 558d5d8c..fb8853b0 100644 --- a/src/test/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersTest.java +++ b/src/test/java/org/gridsuite/voltageinit/server/service/parameters/ParametersTest.java @@ -64,7 +64,7 @@ @AutoConfigureTestEntityManager @Transactional(propagation = Propagation.REQUIRES_NEW) @Slf4j -class VoltageInitParametersTest { +class ParametersTest { private static final UUID NETWORK_UUID = UUID.fromString("7928181c-7977-4592-ba19-88027e4254e4"); private static final String VARIANT_ID_1 = "variant_1"; private static final UUID FILTER_UUID_1 = UUID.fromString("1a3d23a6-7a4c-11ee-b962-0242ac120002"); From ef08b99b26f67b6b3bbc8b774f7e368775e7058b Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Wed, 3 Apr 2024 10:22:25 +0200 Subject: [PATCH 22/53] DB not clean by `@DirtiesContext` ? --- .../voltageinit/server/VoltageInitParametersTest.java | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java index a56865f4..ad68c8f8 100644 --- a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java +++ b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java @@ -13,6 +13,8 @@ import org.gridsuite.voltageinit.server.dto.parameters.VoltageLimitInfos; import org.gridsuite.voltageinit.server.entities.parameters.VoltageInitParametersEntity; import org.gridsuite.voltageinit.server.repository.parameters.VoltageInitParametersRepository; +import org.junit.After; +import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; @@ -54,6 +56,12 @@ public class VoltageInitParametersTest { @Autowired private VoltageInitParametersRepository parametersRepository; + @Before + @After + public void cleanDB() { + parametersRepository.deleteAll(); + } + @Test public void testCreate() throws Exception { From 86fc6fd817b301def36a27c2c6e35160bbff17df Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Wed, 3 Apr 2024 10:57:44 +0200 Subject: [PATCH 23/53] clean PR --- .../service/VoltageInitWorkerService.java | 7 ++-- .../VoltageInitParametersService.java | 8 ++-- .../server/VoltageInitControllerTest.java | 2 - .../server/VoltageInitParametersTest.java | 2 + .../service/ReportServiceTest.java | 16 ++++---- .../assertions/ReflectiveRepresentation.java | 39 ------------------- 6 files changed, 18 insertions(+), 56 deletions(-) delete mode 100644 src/test/java/org/gridsuite/voltageinit/utils/assertions/ReflectiveRepresentation.java diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitWorkerService.java b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitWorkerService.java index 5310300a..017a0f12 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitWorkerService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitWorkerService.java @@ -32,10 +32,7 @@ import org.springframework.web.server.ResponseStatusException; import java.util.*; -import java.util.concurrent.CancellationException; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.TimeUnit; +import java.util.concurrent.*; import java.util.concurrent.atomic.AtomicReference; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; @@ -51,6 +48,7 @@ */ @Service public class VoltageInitWorkerService { + private static final Logger LOGGER = LoggerFactory.getLogger(VoltageInitWorkerService.class); private static final String ERROR = "error"; @@ -136,6 +134,7 @@ public CompletableFuture runVoltageInitAsync(VoltageInitRunConte if (resultUuid != null && cancelComputationRequests.get(resultUuid) != null) { return null; } + OpenReacParameters parameters = voltageInitParametersService.buildOpenReacParameters(context, network); OpenReacConfig config = OpenReacConfig.load(); CompletableFuture future = OpenReacRunner.runAsync(network, network.getVariantManager().getWorkingVariantId(), parameters, config, voltageInitExecutionService.getComputationManager()); diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index de7edceb..8744a3cf 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -6,6 +6,10 @@ */ package org.gridsuite.voltageinit.server.service.parameters; +import java.util.*; +import java.util.concurrent.TimeUnit; +import java.util.stream.Collectors; + import com.powsybl.commons.reporter.Report; import com.powsybl.commons.reporter.Reporter; import com.powsybl.commons.reporter.TypedValue; @@ -29,10 +33,6 @@ import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; -import java.util.*; -import java.util.concurrent.TimeUnit; -import java.util.stream.Collectors; - /** * @author Ayoub LABIDI */ diff --git a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitControllerTest.java b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitControllerTest.java index feb6b14e..6cabfced 100644 --- a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitControllerTest.java +++ b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitControllerTest.java @@ -61,7 +61,6 @@ import org.springframework.cloud.stream.binder.test.TestChannelBinderConfiguration; import org.springframework.http.MediaType; import org.springframework.messaging.Message; -import org.springframework.test.annotation.DirtiesContext; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.ContextHierarchy; import org.springframework.test.context.junit4.SpringRunner; @@ -92,7 +91,6 @@ */ @RunWith(SpringRunner.class) @AutoConfigureMockMvc -@DirtiesContext @SpringBootTest @ContextHierarchy({@ContextConfiguration(classes = {VoltageInitApplication.class, TestChannelBinderConfiguration.class})}) public class VoltageInitControllerTest { diff --git a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java index ad68c8f8..b758cb91 100644 --- a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java +++ b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java @@ -44,7 +44,9 @@ @AutoConfigureMockMvc @Transactional public class VoltageInitParametersTest { + private static final String URI_PARAMETERS_BASE = "/v1/parameters"; + private static final String URI_PARAMETERS_GET_PUT = URI_PARAMETERS_BASE + "/"; @Autowired diff --git a/src/test/java/org/gridsuite/voltageinit/service/ReportServiceTest.java b/src/test/java/org/gridsuite/voltageinit/service/ReportServiceTest.java index 878c0827..e2056cad 100644 --- a/src/test/java/org/gridsuite/voltageinit/service/ReportServiceTest.java +++ b/src/test/java/org/gridsuite/voltageinit/service/ReportServiceTest.java @@ -7,8 +7,11 @@ package org.gridsuite.voltageinit.service; import com.github.tomakehurst.wiremock.WireMockServer; -import com.github.tomakehurst.wiremock.client.WireMock; import com.github.tomakehurst.wiremock.core.WireMockConfiguration; +import com.github.tomakehurst.wiremock.client.WireMock; + +import static com.github.tomakehurst.wiremock.client.WireMock.*; + import com.powsybl.commons.reporter.Reporter; import com.powsybl.commons.reporter.ReporterModel; import org.gridsuite.voltageinit.server.service.ReportService; @@ -25,17 +28,16 @@ import org.springframework.web.client.RestTemplate; import org.springframework.web.util.UriComponentsBuilder; -import java.io.IOException; -import java.net.URI; -import java.net.URISyntaxException; -import java.util.UUID; - -import static com.github.tomakehurst.wiremock.client.WireMock.*; import static org.gridsuite.voltageinit.utils.TestUtils.resourceToString; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; +import java.io.IOException; +import java.net.URI; +import java.net.URISyntaxException; +import java.util.UUID; + /** * @author Anis TOURI */ diff --git a/src/test/java/org/gridsuite/voltageinit/utils/assertions/ReflectiveRepresentation.java b/src/test/java/org/gridsuite/voltageinit/utils/assertions/ReflectiveRepresentation.java deleted file mode 100644 index eb2be624..00000000 --- a/src/test/java/org/gridsuite/voltageinit/utils/assertions/ReflectiveRepresentation.java +++ /dev/null @@ -1,39 +0,0 @@ -package org.gridsuite.voltageinit.utils.assertions; - -import com.google.auto.service.AutoService; -import lombok.extern.slf4j.Slf4j; -import org.apache.commons.lang3.builder.RecursiveToStringStyle; -import org.apache.commons.lang3.builder.ToStringBuilder; -import org.apache.commons.lang3.builder.ToStringStyle; -import org.assertj.core.presentation.Representation; -import org.assertj.core.presentation.StandardRepresentation; -import org.jetbrains.annotations.NotNull; - -import java.lang.reflect.InaccessibleObjectException; - -/** - * AssertJ {@link Representation} for types having no {@link Object#toString() toString()} implemented - */ -@AutoService(Representation.class) -@Slf4j -public class ReflectiveRepresentation extends StandardRepresentation { - /** - * {@inheritDoc} - */ - @Override - protected String fallbackToStringOf(@NotNull final Object object) { - try { - if (Object.class.equals(object.getClass().getMethod("toString").getDeclaringClass())) { - try { - return ToStringBuilder.reflectionToString(object, new RecursiveToStringStyle()); - } catch (final InaccessibleObjectException e) { - //unnamed module haven't opens to java.base/* - return ToStringBuilder.reflectionToString(object, ToStringStyle.DEFAULT_STYLE); - } - } - } catch (NoSuchMethodException e) { - log.warn("Error while analysing object class", e); - } - return object.toString(); - } -} From cf2c51f131349b3c9343a55216c091dbfae8e745 Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Wed, 3 Apr 2024 11:21:00 +0200 Subject: [PATCH 24/53] clean --- .../gridsuite/voltageinit/server/VoltageInitParametersTest.java | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java index b758cb91..37f2649a 100644 --- a/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java +++ b/src/test/java/org/gridsuite/voltageinit/server/VoltageInitParametersTest.java @@ -21,7 +21,6 @@ import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.http.MediaType; -import org.springframework.test.annotation.DirtiesContext; import org.springframework.test.context.junit4.SpringRunner; import org.springframework.test.web.servlet.MockMvc; import org.springframework.test.web.servlet.MvcResult; @@ -40,7 +39,6 @@ */ @RunWith(SpringRunner.class) @SpringBootTest -@DirtiesContext @AutoConfigureMockMvc @Transactional public class VoltageInitParametersTest { From e55c5b2b15f8838330e94993aa2e44c6f77a5a96 Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Wed, 3 Apr 2024 13:53:53 +0200 Subject: [PATCH 25/53] review fix typos and counters --- .../VoltageInitParametersService.java | 32 +++++++++++++++---- .../reporter_buildOpenReacParameters.json | 8 ++--- ...dOpenReacParameters_caseRelativeFalse.json | 10 +++--- ...ldOpenReacParameters_caseRelativeTrue.json | 8 ++--- ...ReacParameters_withLimitModifications.json | 10 +++--- 5 files changed, 43 insertions(+), 25 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index 8744a3cf..b65f916f 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -19,6 +19,7 @@ import com.powsybl.openreac.parameters.input.VoltageLimitOverride; import com.powsybl.openreac.parameters.input.VoltageLimitOverride.VoltageLimitType; import com.powsybl.openreac.parameters.input.algo.ReactiveSlackBusesMode; +import org.apache.commons.lang3.tuple.MutablePair; import org.gridsuite.voltageinit.server.dto.parameters.FilterEquipments; import org.gridsuite.voltageinit.server.dto.parameters.IdentifiableAttributes; import org.gridsuite.voltageinit.server.dto.parameters.VoltageInitParametersInfos; @@ -156,7 +157,7 @@ private static void setHighVoltageLimit(List specificVolta @Transactional(readOnly = true) public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, Network network) { final long startTime = System.nanoTime(); - final Reporter reporter = context.getRootReporter().createSubReporter("OpenReactParameters", "OpenReact parameters", Map.of( + final Reporter reporter = context.getRootReporter().createSubReporter("OpenReacParameters", "OpenReac parameters", Map.of( "parameters_id", new TypedValue(Objects.toString(context.getParametersUuid()), "ID") )); @@ -208,18 +209,20 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, .addVariableTwoWindingsTransformers(variableTwoWindingsTransformers) .addVariableShuntCompensators(variableShuntCompensators); - long nbMissingVoltageLimits = 0L; - long nbVoltageLimitModifications = 0L; + // use Pair(nbMissingVoltageLimits, nbVoltageLimitModifications) because of "Variable used in lambda expression should be final or effectively final" + final MutablePair nbVoltages = MutablePair.ofNonNull(0, 0); parameters.getSpecificVoltageLimits() .stream() .collect(Collectors.groupingBy(VoltageLimitOverride::getVoltageLevelId)) .forEach((id, voltageLimits) -> { final Map newLimits = voltageLimits.stream() - .collect(Collectors.groupingBy(VoltageLimitOverride::getVoltageLimitType, Collectors.summingDouble(VoltageLimitOverride::getLimit))); + .collect(Collectors.groupingBy(VoltageLimitOverride::getVoltageLimitType, + () -> new EnumMap<>(VoltageLimitType.class), + Collectors.summingDouble(VoltageLimitOverride::getLimit))); final VoltageLevel voltageLevel = network.getVoltageLevel(id); reporter.report(Report.builder() .withKey("voltageLimitModified") - .withDefaultMessage("On or two voltage limits of voltage level ${voltageLevelId} have been replaced and/or modified low voltage limit = ${newLowVoltageLimit}kV, high voltage limit = ${newHighVoltageLimit}kV (initial values: low voltage limit = ${initialLowVoltageLimit}kV, high voltage limit = ${initialHighVoltage}kV).") + .withDefaultMessage("One or two voltage limits of voltage level ${voltageLevelId} have been replaced and/or modified: low voltage limit = ${newLowVoltageLimit}\u202FkV, high voltage limit = ${newHighVoltageLimit}\u202FkV (initial values: low voltage limit = ${initialLowVoltageLimit}\u202FkV, high voltage limit = ${initialHighVoltage}\u202FkV).") .withTypedValue("voltageLevelId", voltageLevel.getId(), TypedValue.VOLTAGE_LEVEL) .withTypedValue("newLowVoltageLimit", newLimits.getOrDefault(VoltageLimitType.LOW_VOLTAGE_LIMIT, voltageLevel.getLowVoltageLimit()), TypedValue.VOLTAGE) .withTypedValue("newHighVoltageLimit", newLimits.getOrDefault(VoltageLimitType.HIGH_VOLTAGE_LIMIT, voltageLevel.getHighVoltageLimit()), TypedValue.VOLTAGE) @@ -227,17 +230,32 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, .withTypedValue("initialHighVoltage", voltageLevel.getHighVoltageLimit(), TypedValue.VOLTAGE) .withSeverity(TypedValue.TRACE_SEVERITY) .build()); + // update counters for resume logs + if (newLimits.containsKey(VoltageLimitType.LOW_VOLTAGE_LIMIT)) { + if (Double.isNaN(voltageLevel.getLowVoltageLimit())) { + nbVoltages.left++; + } else { + nbVoltages.right++; + } + } + if (newLimits.containsKey(VoltageLimitType.HIGH_VOLTAGE_LIMIT)) { + if (Double.isNaN(voltageLevel.getHighVoltageLimit())) { + nbVoltages.left++; + } else { + nbVoltages.right++; + } + } }); reporter.report(Report.builder() .withKey("missingVoltageLimits") .withDefaultMessage("Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.") - .withValue("nbMissingVoltageLimits", nbMissingVoltageLimits) + .withValue("nbMissingVoltageLimits", nbVoltages.getLeft()) .withSeverity(TypedValue.INFO_SEVERITY) .build()); reporter.report(Report.builder() .withKey("voltageLimitModifications") .withDefaultMessage("Voltage limits of ${nbVoltageLimitModifications} voltage levels have been modified according to user input.") - .withValue("nbVoltageLimitModifications", nbVoltageLimitModifications) + .withValue("nbVoltageLimitModifications", nbVoltages.getRight()) .withSeverity(TypedValue.INFO_SEVERITY) .build()); diff --git a/src/test/resources/reporter_buildOpenReacParameters.json b/src/test/resources/reporter_buildOpenReacParameters.json index d40cf868..333c099c 100644 --- a/src/test/resources/reporter_buildOpenReacParameters.json +++ b/src/test/resources/reporter_buildOpenReacParameters.json @@ -4,7 +4,7 @@ "taskKey": "VoltageInit", "subReporters": [ { - "taskKey": "OpenReactParameters", + "taskKey": "OpenReacParameters", "taskValues": { "parameters_id": { "value": "11111111-1111-1111-1111-111111111111", @@ -103,7 +103,7 @@ "reportKey": "missingVoltageLimits", "values": { "nbMissingVoltageLimits": { - "value": 0 + "value": 4 }, "reportSeverity": { "value": "INFO", @@ -131,9 +131,9 @@ "default": { "voltageLimitModifications": "Voltage limits of ${nbVoltageLimitModifications} voltage levels have been modified according to user input.", "VoltageInit": "VoltageInit", - "OpenReactParameters": "OpenReact parameters", + "OpenReacParameters": "OpenReac parameters", "missingVoltageLimits": "Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.", - "voltageLimitModified": "On or two voltage limits of voltage level ${voltageLevelId} have been replaced and/or modified low voltage limit = ${newLowVoltageLimit}kV, high voltage limit = ${newHighVoltageLimit}kV (initial values: low voltage limit = ${initialLowVoltageLimit}kV, high voltage limit = ${initialHighVoltage}kV)." + "voltageLimitModified": "One or two voltage limits of voltage level ${voltageLevelId} have been replaced and/or modified: low voltage limit = ${newLowVoltageLimit} kV, high voltage limit = ${newHighVoltageLimit} kV (initial values: low voltage limit = ${initialLowVoltageLimit} kV, high voltage limit = ${initialHighVoltage} kV)." } } } diff --git a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json index 2f105665..4254060b 100644 --- a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json +++ b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json @@ -4,7 +4,7 @@ "taskKey": "VoltageInit", "subReporters": [ { - "taskKey": "OpenReactParameters", + "taskKey": "OpenReacParameters", "taskValues": { "parameters_id": { "value": "11111111-1111-1111-1111-111111111111", @@ -144,7 +144,7 @@ "reportKey": "missingVoltageLimits", "values": { "nbMissingVoltageLimits": { - "value": 0 + "value": 4 }, "reportSeverity": { "value": "INFO", @@ -160,7 +160,7 @@ "type": "SEVERITY" }, "nbVoltageLimitModifications": { - "value": 0 + "value": 4 } } } @@ -173,9 +173,9 @@ "restrictedVoltageLevels": "The modifications to the low limits for certain voltage levels have been restricted to avoid negative voltage limits: ${joinedVoltageLevelsIds}", "voltageLimitModifications": "Voltage limits of ${nbVoltageLimitModifications} voltage levels have been modified according to user input.", "VoltageInit": "VoltageInit", - "OpenReactParameters": "OpenReact parameters", + "OpenReacParameters": "OpenReac parameters", "missingVoltageLimits": "Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.", - "voltageLimitModified": "On or two voltage limits of voltage level ${voltageLevelId} have been replaced and/or modified low voltage limit = ${newLowVoltageLimit}kV, high voltage limit = ${newHighVoltageLimit}kV (initial values: low voltage limit = ${initialLowVoltageLimit}kV, high voltage limit = ${initialHighVoltage}kV)." + "voltageLimitModified": "One or two voltage limits of voltage level ${voltageLevelId} have been replaced and/or modified: low voltage limit = ${newLowVoltageLimit} kV, high voltage limit = ${newHighVoltageLimit} kV (initial values: low voltage limit = ${initialLowVoltageLimit} kV, high voltage limit = ${initialHighVoltage} kV)." } } } diff --git a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json index a9413d21..1d8262f7 100644 --- a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json +++ b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json @@ -4,7 +4,7 @@ "taskKey": "VoltageInit", "subReporters": [ { - "taskKey": "OpenReactParameters", + "taskKey": "OpenReacParameters", "taskValues": { "parameters_id": { "value": "11111111-1111-1111-1111-111111111111", @@ -131,7 +131,7 @@ "type": "SEVERITY" }, "nbVoltageLimitModifications": { - "value": 0 + "value": 4 } } } @@ -144,9 +144,9 @@ "restrictedVoltageLevels": "The modifications to the low limits for certain voltage levels have been restricted to avoid negative voltage limits: ${joinedVoltageLevelsIds}", "voltageLimitModifications": "Voltage limits of ${nbVoltageLimitModifications} voltage levels have been modified according to user input.", "VoltageInit": "VoltageInit", - "OpenReactParameters": "OpenReact parameters", + "OpenReacParameters": "OpenReac parameters", "missingVoltageLimits": "Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.", - "voltageLimitModified": "On or two voltage limits of voltage level ${voltageLevelId} have been replaced and/or modified low voltage limit = ${newLowVoltageLimit}kV, high voltage limit = ${newHighVoltageLimit}kV (initial values: low voltage limit = ${initialLowVoltageLimit}kV, high voltage limit = ${initialHighVoltage}kV)." + "voltageLimitModified": "One or two voltage limits of voltage level ${voltageLevelId} have been replaced and/or modified: low voltage limit = ${newLowVoltageLimit} kV, high voltage limit = ${newHighVoltageLimit} kV (initial values: low voltage limit = ${initialLowVoltageLimit} kV, high voltage limit = ${initialHighVoltage} kV)." } } } diff --git a/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json b/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json index 363ef76e..f18daf14 100644 --- a/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json +++ b/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json @@ -4,7 +4,7 @@ "taskKey": "VoltageInit", "subReporters": [ { - "taskKey": "OpenReactParameters", + "taskKey": "OpenReacParameters", "taskValues": { "parameters_id": { "value": "11111111-1111-1111-1111-111111111111", @@ -132,7 +132,7 @@ "reportKey": "missingVoltageLimits", "values": { "nbMissingVoltageLimits": { - "value": 0 + "value": 4 }, "reportSeverity": { "value": "INFO", @@ -148,7 +148,7 @@ "type": "SEVERITY" }, "nbVoltageLimitModifications": { - "value": 0 + "value": 4 } } } @@ -160,9 +160,9 @@ "default": { "voltageLimitModifications": "Voltage limits of ${nbVoltageLimitModifications} voltage levels have been modified according to user input.", "VoltageInit": "VoltageInit", - "OpenReactParameters": "OpenReact parameters", + "OpenReacParameters": "OpenReac parameters", "missingVoltageLimits": "Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.", - "voltageLimitModified": "On or two voltage limits of voltage level ${voltageLevelId} have been replaced and/or modified low voltage limit = ${newLowVoltageLimit}kV, high voltage limit = ${newHighVoltageLimit}kV (initial values: low voltage limit = ${initialLowVoltageLimit}kV, high voltage limit = ${initialHighVoltage}kV)." + "voltageLimitModified": "One or two voltage limits of voltage level ${voltageLevelId} have been replaced and/or modified: low voltage limit = ${newLowVoltageLimit} kV, high voltage limit = ${newHighVoltageLimit} kV (initial values: low voltage limit = ${initialLowVoltageLimit} kV, high voltage limit = ${initialHighVoltage} kV)." } } } From 482d1ff2c9bdf8b9db8e3f012a5b0076a3ada06d Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Thu, 4 Apr 2024 21:29:40 +0200 Subject: [PATCH 26/53] fix: relative override need to be calculated --- .../VoltageInitParametersService.java | 37 +++++++++++++------ ...dOpenReacParameters_caseRelativeFalse.json | 10 ++--- ...ldOpenReacParameters_caseRelativeTrue.json | 10 ++--- ...ReacParameters_withLimitModifications.json | 10 ++--- 4 files changed, 41 insertions(+), 26 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index b65f916f..92a1d885 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -29,6 +29,7 @@ import org.gridsuite.voltageinit.server.repository.parameters.VoltageInitParametersRepository; import org.gridsuite.voltageinit.server.service.VoltageInitRunContext; import org.gridsuite.voltageinit.server.util.VoltageLimitParameterType; +import org.jetbrains.annotations.Nullable; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.stereotype.Service; @@ -213,32 +214,38 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, final MutablePair nbVoltages = MutablePair.ofNonNull(0, 0); parameters.getSpecificVoltageLimits() .stream() - .collect(Collectors.groupingBy(VoltageLimitOverride::getVoltageLevelId)) + .collect(HashMap>::new, + (map, voltageLimitOverride) -> map + .computeIfAbsent(voltageLimitOverride.getVoltageLevelId(), key -> new EnumMap<>(VoltageLimitType.class)) + .put(voltageLimitOverride.getVoltageLimitType(), voltageLimitOverride), + (map, map2) -> map2.forEach((id, newLimits) -> map.merge(id, newLimits, (nl1, nl2) -> { + nl1.putAll(nl2); + return nl1; + }) + )) .forEach((id, voltageLimits) -> { - final Map newLimits = voltageLimits.stream() - .collect(Collectors.groupingBy(VoltageLimitOverride::getVoltageLimitType, - () -> new EnumMap<>(VoltageLimitType.class), - Collectors.summingDouble(VoltageLimitOverride::getLimit))); final VoltageLevel voltageLevel = network.getVoltageLevel(id); + final double initialLowVoltageLimit = voltageLevel.getLowVoltageLimit(); + final double initialHighVoltage = voltageLevel.getHighVoltageLimit(); reporter.report(Report.builder() .withKey("voltageLimitModified") .withDefaultMessage("One or two voltage limits of voltage level ${voltageLevelId} have been replaced and/or modified: low voltage limit = ${newLowVoltageLimit}\u202FkV, high voltage limit = ${newHighVoltageLimit}\u202FkV (initial values: low voltage limit = ${initialLowVoltageLimit}\u202FkV, high voltage limit = ${initialHighVoltage}\u202FkV).") .withTypedValue("voltageLevelId", voltageLevel.getId(), TypedValue.VOLTAGE_LEVEL) - .withTypedValue("newLowVoltageLimit", newLimits.getOrDefault(VoltageLimitType.LOW_VOLTAGE_LIMIT, voltageLevel.getLowVoltageLimit()), TypedValue.VOLTAGE) - .withTypedValue("newHighVoltageLimit", newLimits.getOrDefault(VoltageLimitType.HIGH_VOLTAGE_LIMIT, voltageLevel.getHighVoltageLimit()), TypedValue.VOLTAGE) - .withTypedValue("initialLowVoltageLimit", voltageLevel.getLowVoltageLimit(), TypedValue.VOLTAGE) - .withTypedValue("initialHighVoltage", voltageLevel.getHighVoltageLimit(), TypedValue.VOLTAGE) + .withTypedValue("newLowVoltageLimit", computeRelativeVoltageLevel(initialLowVoltageLimit, voltageLimits.get(VoltageLimitType.LOW_VOLTAGE_LIMIT)), TypedValue.VOLTAGE) + .withTypedValue("newHighVoltageLimit", computeRelativeVoltageLevel(initialHighVoltage, voltageLimits.get(VoltageLimitType.HIGH_VOLTAGE_LIMIT)), TypedValue.VOLTAGE) + .withTypedValue("initialLowVoltageLimit", initialLowVoltageLimit, TypedValue.VOLTAGE) + .withTypedValue("initialHighVoltage", initialHighVoltage, TypedValue.VOLTAGE) .withSeverity(TypedValue.TRACE_SEVERITY) .build()); // update counters for resume logs - if (newLimits.containsKey(VoltageLimitType.LOW_VOLTAGE_LIMIT)) { + if (voltageLimits.containsKey(VoltageLimitType.LOW_VOLTAGE_LIMIT)) { if (Double.isNaN(voltageLevel.getLowVoltageLimit())) { nbVoltages.left++; } else { nbVoltages.right++; } } - if (newLimits.containsKey(VoltageLimitType.HIGH_VOLTAGE_LIMIT)) { + if (voltageLimits.containsKey(VoltageLimitType.HIGH_VOLTAGE_LIMIT)) { if (Double.isNaN(voltageLevel.getHighVoltageLimit())) { nbVoltages.left++; } else { @@ -279,4 +286,12 @@ private List toEquipmentIdsList(UUID networkUuid, String variantId, List ); return new ArrayList<>(ids); } + + private double computeRelativeVoltageLevel(final double initialVoltageLimit, @Nullable final VoltageLimitOverride override) { + if (override == null) { + return initialVoltageLimit; + } else { + return (override.isRelative() ? initialVoltageLimit : 0.0) + override.getLimit(); + } + } } diff --git a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json index 4254060b..394093e9 100644 --- a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json +++ b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json @@ -48,7 +48,7 @@ "type": "VOLTAGE" }, "newLowVoltageLimit": { - "value": -10.0, + "value": 0.0, "type": "VOLTAGE" } } @@ -69,7 +69,7 @@ "type": "SEVERITY" }, "newHighVoltageLimit": { - "value": 10.0, + "value": 30.0, "type": "VOLTAGE" }, "initialHighVoltage": { @@ -98,7 +98,7 @@ "type": "SEVERITY" }, "newHighVoltageLimit": { - "value": 10.0, + "value": 30.0, "type": "VOLTAGE" }, "initialHighVoltage": { @@ -106,7 +106,7 @@ "type": "VOLTAGE" }, "newLowVoltageLimit": { - "value": -10.0, + "value": 0.0, "type": "VOLTAGE" } } @@ -172,8 +172,8 @@ "default": { "restrictedVoltageLevels": "The modifications to the low limits for certain voltage levels have been restricted to avoid negative voltage limits: ${joinedVoltageLevelsIds}", "voltageLimitModifications": "Voltage limits of ${nbVoltageLimitModifications} voltage levels have been modified according to user input.", - "VoltageInit": "VoltageInit", "OpenReacParameters": "OpenReac parameters", + "VoltageInit": "VoltageInit", "missingVoltageLimits": "Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.", "voltageLimitModified": "One or two voltage limits of voltage level ${voltageLevelId} have been replaced and/or modified: low voltage limit = ${newLowVoltageLimit} kV, high voltage limit = ${newHighVoltageLimit} kV (initial values: low voltage limit = ${initialLowVoltageLimit} kV, high voltage limit = ${initialHighVoltage} kV)." } diff --git a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json index 1d8262f7..75824ae9 100644 --- a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json +++ b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json @@ -48,7 +48,7 @@ "type": "VOLTAGE" }, "newLowVoltageLimit": { - "value": -10.0, + "value": 0.0, "type": "VOLTAGE" } } @@ -69,7 +69,7 @@ "type": "SEVERITY" }, "newHighVoltageLimit": { - "value": 10.0, + "value": 30.0, "type": "VOLTAGE" }, "initialHighVoltage": { @@ -98,7 +98,7 @@ "type": "SEVERITY" }, "newHighVoltageLimit": { - "value": 10.0, + "value": 30.0, "type": "VOLTAGE" }, "initialHighVoltage": { @@ -106,7 +106,7 @@ "type": "VOLTAGE" }, "newLowVoltageLimit": { - "value": -10.0, + "value": 0.0, "type": "VOLTAGE" } } @@ -143,8 +143,8 @@ "default": { "restrictedVoltageLevels": "The modifications to the low limits for certain voltage levels have been restricted to avoid negative voltage limits: ${joinedVoltageLevelsIds}", "voltageLimitModifications": "Voltage limits of ${nbVoltageLimitModifications} voltage levels have been modified according to user input.", - "VoltageInit": "VoltageInit", "OpenReacParameters": "OpenReac parameters", + "VoltageInit": "VoltageInit", "missingVoltageLimits": "Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.", "voltageLimitModified": "One or two voltage limits of voltage level ${voltageLevelId} have been replaced and/or modified: low voltage limit = ${newLowVoltageLimit} kV, high voltage limit = ${newHighVoltageLimit} kV (initial values: low voltage limit = ${initialLowVoltageLimit} kV, high voltage limit = ${initialHighVoltage} kV)." } diff --git a/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json b/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json index f18daf14..f501c5a6 100644 --- a/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json +++ b/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json @@ -36,7 +36,7 @@ "type": "VOLTAGE" }, "newLowVoltageLimit": { - "value": -1.0, + "value": 9.0, "type": "VOLTAGE" } } @@ -57,7 +57,7 @@ "type": "SEVERITY" }, "newHighVoltageLimit": { - "value": -2.0, + "value": 18.0, "type": "VOLTAGE" }, "initialHighVoltage": { @@ -86,7 +86,7 @@ "type": "SEVERITY" }, "newHighVoltageLimit": { - "value": -2.0, + "value": 18.0, "type": "VOLTAGE" }, "initialHighVoltage": { @@ -94,7 +94,7 @@ "type": "VOLTAGE" }, "newLowVoltageLimit": { - "value": -1.0, + "value": 9.0, "type": "VOLTAGE" } } @@ -159,8 +159,8 @@ "dics": { "default": { "voltageLimitModifications": "Voltage limits of ${nbVoltageLimitModifications} voltage levels have been modified according to user input.", - "VoltageInit": "VoltageInit", "OpenReacParameters": "OpenReac parameters", + "VoltageInit": "VoltageInit", "missingVoltageLimits": "Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.", "voltageLimitModified": "One or two voltage limits of voltage level ${voltageLevelId} have been replaced and/or modified: low voltage limit = ${newLowVoltageLimit} kV, high voltage limit = ${newHighVoltageLimit} kV (initial values: low voltage limit = ${initialLowVoltageLimit} kV, high voltage limit = ${initialHighVoltage} kV)." } From 59af616fecb343e8c7b141925d4988e3453e8eec Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Thu, 4 Apr 2024 21:43:53 +0200 Subject: [PATCH 27/53] fix limits set counters --- .../VoltageInitParametersService.java | 50 ++++++++++--------- ...dOpenReacParameters_caseRelativeFalse.json | 2 +- ...ReacParameters_withLimitModifications.json | 2 +- 3 files changed, 29 insertions(+), 25 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index 92a1d885..54955bd7 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -19,7 +19,7 @@ import com.powsybl.openreac.parameters.input.VoltageLimitOverride; import com.powsybl.openreac.parameters.input.VoltageLimitOverride.VoltageLimitType; import com.powsybl.openreac.parameters.input.algo.ReactiveSlackBusesMode; -import org.apache.commons.lang3.tuple.MutablePair; +import org.apache.commons.lang3.mutable.MutableInt; import org.gridsuite.voltageinit.server.dto.parameters.FilterEquipments; import org.gridsuite.voltageinit.server.dto.parameters.IdentifiableAttributes; import org.gridsuite.voltageinit.server.dto.parameters.VoltageInitParametersInfos; @@ -98,6 +98,8 @@ private Map resolveVoltageLevelLimits(VoltageInitRun } private static void fillSpecificVoltageLimits(List specificVoltageLimits, + final MutableInt counterMissingVoltageLimits, + final MutableInt counterVoltageLimitModifications, Map voltageLevelModificationLimits, Map voltageLevelDefaultLimits, VoltageLevel voltageLevel, @@ -107,11 +109,13 @@ private static void fillSpecificVoltageLimits(List specifi boolean isLowVoltageLimitDefaultSet = voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) && voltageLevelDefaultLimits.get(voltageLevel.getId()).getLowVoltageLimit() != null; boolean isHighVoltageLimitDefaultSet = voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) && voltageLevelDefaultLimits.get(voltageLevel.getId()).getHighVoltageLimit() != null; - setLowVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isLowVoltageLimitModificationSet, isLowVoltageLimitDefaultSet, voltageLevel, voltageLevelsIdsRestricted); - setHighVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isHighVoltageLimitModificationSet, isHighVoltageLimitDefaultSet, voltageLevel); + setLowVoltageLimit(specificVoltageLimits, counterMissingVoltageLimits, counterVoltageLimitModifications, voltageLevelModificationLimits, voltageLevelDefaultLimits, isLowVoltageLimitModificationSet, isLowVoltageLimitDefaultSet, voltageLevel, voltageLevelsIdsRestricted); + setHighVoltageLimit(specificVoltageLimits, counterMissingVoltageLimits, counterVoltageLimitModifications, voltageLevelModificationLimits, voltageLevelDefaultLimits, isHighVoltageLimitModificationSet, isHighVoltageLimitDefaultSet, voltageLevel); } private static void setLowVoltageLimit(List specificVoltageLimits, + final MutableInt counterMissingVoltageLimits, + final MutableInt counterVoltageLimitModifications, Map voltageLevelModificationLimits, Map voltageLevelDefaultLimits, boolean isLowVoltageLimitModificationSet, @@ -129,6 +133,7 @@ private static void setLowVoltageLimit(List specificVoltag newLowVoltageLimit = lowVoltageLimitModification; } specificVoltageLimits.add(new VoltageLimitOverride(voltageLevel.getId(), VoltageLimitType.LOW_VOLTAGE_LIMIT, true, newLowVoltageLimit)); + counterVoltageLimitModifications.increment(); } else if (Double.isNaN(lowVoltageLimit) && isLowVoltageLimitDefaultSet) { double voltageLimit = voltageLevelDefaultLimits.get(voltageLevel.getId()).getLowVoltageLimit() + (isLowVoltageLimitModificationSet ? voltageLevelModificationLimits.get(voltageLevel.getId()).getLowVoltageLimit() : 0.); @@ -139,10 +144,16 @@ private static void setLowVoltageLimit(List specificVoltag newLowVoltageLimit = voltageLimit; } specificVoltageLimits.add(new VoltageLimitOverride(voltageLevel.getId(), VoltageLimitType.LOW_VOLTAGE_LIMIT, false, newLowVoltageLimit)); + counterMissingVoltageLimits.increment(); + if (isLowVoltageLimitModificationSet) { + counterVoltageLimitModifications.increment(); + } } } private static void setHighVoltageLimit(List specificVoltageLimits, + final MutableInt counterMissingVoltageLimits, + final MutableInt counterVoltageLimitModifications, Map voltageLevelModificationLimits, Map voltageLevelDefaultLimits, boolean isHighVoltageLimitModificationSet, @@ -150,8 +161,13 @@ private static void setHighVoltageLimit(List specificVolta VoltageLevel voltageLevel) { if (!Double.isNaN(voltageLevel.getHighVoltageLimit()) && isHighVoltageLimitModificationSet) { specificVoltageLimits.add(new VoltageLimitOverride(voltageLevel.getId(), VoltageLimitType.HIGH_VOLTAGE_LIMIT, true, voltageLevelModificationLimits.get(voltageLevel.getId()).getHighVoltageLimit())); + counterVoltageLimitModifications.increment(); } else if (Double.isNaN(voltageLevel.getHighVoltageLimit()) && isHighVoltageLimitDefaultSet) { specificVoltageLimits.add(new VoltageLimitOverride(voltageLevel.getId(), VoltageLimitType.HIGH_VOLTAGE_LIMIT, false, voltageLevelDefaultLimits.get(voltageLevel.getId()).getHighVoltageLimit() + (isHighVoltageLimitModificationSet ? voltageLevelModificationLimits.get(voltageLevel.getId()).getHighVoltageLimit() : 0.))); + counterMissingVoltageLimits.increment(); + if (isHighVoltageLimitModificationSet) { + counterVoltageLimitModifications.increment(); + } } } @@ -172,6 +188,8 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, List constantQGenerators = new ArrayList<>(); List variableTwoWindingsTransformers = new ArrayList<>(); List variableShuntCompensators = new ArrayList<>(); + final MutableInt counterMissingVoltageLimits = new MutableInt(0); + final MutableInt counterVoltageLimitModifications = new MutableInt(0); voltageInitParametersEntity.ifPresent(voltageInitParameters -> { if (voltageInitParameters.getVoltageLimits() != null) { @@ -185,7 +203,10 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, network.getVoltageLevelStream() .filter(voltageLevel -> voltageLevelDefaultLimits.keySet().contains(voltageLevel.getId()) || voltageLevelModificationLimits.keySet().contains(voltageLevel.getId())) - .forEach(voltageLevel -> fillSpecificVoltageLimits(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, voltageLevel, context.getVoltageLevelsIdsRestricted())); + .forEach(voltageLevel -> fillSpecificVoltageLimits(specificVoltageLimits, + counterMissingVoltageLimits, counterVoltageLimitModifications, + voltageLevelModificationLimits, voltageLevelDefaultLimits, + voltageLevel, context.getVoltageLevelsIdsRestricted())); if (!context.getVoltageLevelsIdsRestricted().isEmpty()) { reporter.report(Report.builder() @@ -210,8 +231,6 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, .addVariableTwoWindingsTransformers(variableTwoWindingsTransformers) .addVariableShuntCompensators(variableShuntCompensators); - // use Pair(nbMissingVoltageLimits, nbVoltageLimitModifications) because of "Variable used in lambda expression should be final or effectively final" - final MutablePair nbVoltages = MutablePair.ofNonNull(0, 0); parameters.getSpecificVoltageLimits() .stream() .collect(HashMap>::new, @@ -237,32 +256,17 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, .withTypedValue("initialHighVoltage", initialHighVoltage, TypedValue.VOLTAGE) .withSeverity(TypedValue.TRACE_SEVERITY) .build()); - // update counters for resume logs - if (voltageLimits.containsKey(VoltageLimitType.LOW_VOLTAGE_LIMIT)) { - if (Double.isNaN(voltageLevel.getLowVoltageLimit())) { - nbVoltages.left++; - } else { - nbVoltages.right++; - } - } - if (voltageLimits.containsKey(VoltageLimitType.HIGH_VOLTAGE_LIMIT)) { - if (Double.isNaN(voltageLevel.getHighVoltageLimit())) { - nbVoltages.left++; - } else { - nbVoltages.right++; - } - } }); reporter.report(Report.builder() .withKey("missingVoltageLimits") .withDefaultMessage("Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.") - .withValue("nbMissingVoltageLimits", nbVoltages.getLeft()) + .withValue("nbMissingVoltageLimits", counterMissingVoltageLimits.longValue()) .withSeverity(TypedValue.INFO_SEVERITY) .build()); reporter.report(Report.builder() .withKey("voltageLimitModifications") .withDefaultMessage("Voltage limits of ${nbVoltageLimitModifications} voltage levels have been modified according to user input.") - .withValue("nbVoltageLimitModifications", nbVoltages.getRight()) + .withValue("nbVoltageLimitModifications", counterVoltageLimitModifications.longValue()) .withSeverity(TypedValue.INFO_SEVERITY) .build()); diff --git a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json index 394093e9..abef6aec 100644 --- a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json +++ b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json @@ -160,7 +160,7 @@ "type": "SEVERITY" }, "nbVoltageLimitModifications": { - "value": 4 + "value": 8 } } } diff --git a/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json b/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json index f501c5a6..060cbd8f 100644 --- a/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json +++ b/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json @@ -148,7 +148,7 @@ "type": "SEVERITY" }, "nbVoltageLimitModifications": { - "value": 4 + "value": 8 } } } From 61944b6a372d472f0fe77fdc62809e7f0fd570a7 Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Thu, 4 Apr 2024 21:48:04 +0200 Subject: [PATCH 28/53] review --- .../server/service/parameters/VoltageInitParametersService.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index 54955bd7..49268f9b 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -215,7 +215,7 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, .withValue("joinedVoltageLevelsIds", context.getVoltageLevelsIdsRestricted() .entrySet() .stream() - .map(entry -> entry.getKey() + "=" + entry.getValue()) + .map(entry -> entry.getKey() + ":" + entry.getValue()) .collect(Collectors.joining(", "))) .withSeverity(TypedValue.WARN_SEVERITY) .build()); From 37d7f93ce676a723b2cd2448b133b698e52d79df Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Fri, 5 Apr 2024 16:28:12 +0200 Subject: [PATCH 29/53] review --- .../server/service/parameters/VoltageInitParametersService.java | 2 +- .../reporter_buildOpenReacParameters_caseRelativeFalse.json | 2 +- .../reporter_buildOpenReacParameters_caseRelativeTrue.json | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index 49268f9b..5dd28b6d 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -215,7 +215,7 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, .withValue("joinedVoltageLevelsIds", context.getVoltageLevelsIdsRestricted() .entrySet() .stream() - .map(entry -> entry.getKey() + ":" + entry.getValue()) + .map(entry -> entry.getKey() + " : " + entry.getValue()) .collect(Collectors.joining(", "))) .withSeverity(TypedValue.WARN_SEVERITY) .build()); diff --git a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json index abef6aec..f99ba077 100644 --- a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json +++ b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json @@ -20,7 +20,7 @@ "type": "SEVERITY" }, "joinedVoltageLevelsIds": { - "value": "VLHV2=-10.0, VLHV1=0.0, VLGEN=-10.0, VLLOAD=0.0" + "value": "VLHV2 : -10.0, VLHV1 : 0.0, VLGEN : -10.0, VLLOAD : 0.0" } } }, diff --git a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json index 75824ae9..b9062df9 100644 --- a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json +++ b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json @@ -20,7 +20,7 @@ "type": "SEVERITY" }, "joinedVoltageLevelsIds": { - "value": "VLHV2=-10.0, VLGEN=-10.0" + "value": "VLHV2 : -10.0, VLGEN : -10.0" } } }, From c6803d292488a090f5a5be507eb5f15de1dbe9c9 Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Fri, 5 Apr 2024 16:29:51 +0200 Subject: [PATCH 30/53] fix counter --- .../VoltageInitParametersService.java | 69 ++++++++++++------- .../reporter_buildOpenReacParameters.json | 6 +- ...dOpenReacParameters_caseRelativeFalse.json | 4 +- ...ldOpenReacParameters_caseRelativeTrue.json | 2 +- ...ReacParameters_withLimitModifications.json | 4 +- 5 files changed, 52 insertions(+), 33 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index 5dd28b6d..5a8cc89e 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -19,6 +19,7 @@ import com.powsybl.openreac.parameters.input.VoltageLimitOverride; import com.powsybl.openreac.parameters.input.VoltageLimitOverride.VoltageLimitType; import com.powsybl.openreac.parameters.input.algo.ReactiveSlackBusesMode; +import lombok.NonNull; import org.apache.commons.lang3.mutable.MutableInt; import org.gridsuite.voltageinit.server.dto.parameters.FilterEquipments; import org.gridsuite.voltageinit.server.dto.parameters.IdentifiableAttributes; @@ -109,19 +110,24 @@ private static void fillSpecificVoltageLimits(List specifi boolean isLowVoltageLimitDefaultSet = voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) && voltageLevelDefaultLimits.get(voltageLevel.getId()).getLowVoltageLimit() != null; boolean isHighVoltageLimitDefaultSet = voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) && voltageLevelDefaultLimits.get(voltageLevel.getId()).getHighVoltageLimit() != null; - setLowVoltageLimit(specificVoltageLimits, counterMissingVoltageLimits, counterVoltageLimitModifications, voltageLevelModificationLimits, voltageLevelDefaultLimits, isLowVoltageLimitModificationSet, isLowVoltageLimitDefaultSet, voltageLevel, voltageLevelsIdsRestricted); - setHighVoltageLimit(specificVoltageLimits, counterMissingVoltageLimits, counterVoltageLimitModifications, voltageLevelModificationLimits, voltageLevelDefaultLimits, isHighVoltageLimitModificationSet, isHighVoltageLimitDefaultSet, voltageLevel); + switch (generateLowVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isLowVoltageLimitModificationSet, isLowVoltageLimitDefaultSet, voltageLevel, voltageLevelsIdsRestricted) + .merge(generateHighVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isHighVoltageLimitModificationSet, isHighVoltageLimitDefaultSet, voltageLevel))) { + case DEFAULT -> counterMissingVoltageLimits.increment(); + case MODIFICATION -> counterVoltageLimitModifications.increment(); + case BOTH -> { + counterMissingVoltageLimits.increment(); + counterVoltageLimitModifications.increment(); + } + } } - private static void setLowVoltageLimit(List specificVoltageLimits, - final MutableInt counterMissingVoltageLimits, - final MutableInt counterVoltageLimitModifications, - Map voltageLevelModificationLimits, - Map voltageLevelDefaultLimits, - boolean isLowVoltageLimitModificationSet, - boolean isLowVoltageLimitDefaultSet, - VoltageLevel voltageLevel, - Map voltageLevelsIdsRestricted) { + private static CountVoltageLimit generateLowVoltageLimit(List specificVoltageLimits, + Map voltageLevelModificationLimits, + Map voltageLevelDefaultLimits, + boolean isLowVoltageLimitModificationSet, + boolean isLowVoltageLimitDefaultSet, + VoltageLevel voltageLevel, + Map voltageLevelsIdsRestricted) { double newLowVoltageLimit; double lowVoltageLimit = voltageLevel.getLowVoltageLimit(); if (!Double.isNaN(lowVoltageLimit) && isLowVoltageLimitModificationSet) { @@ -133,7 +139,7 @@ private static void setLowVoltageLimit(List specificVoltag newLowVoltageLimit = lowVoltageLimitModification; } specificVoltageLimits.add(new VoltageLimitOverride(voltageLevel.getId(), VoltageLimitType.LOW_VOLTAGE_LIMIT, true, newLowVoltageLimit)); - counterVoltageLimitModifications.increment(); + return CountVoltageLimit.MODIFICATION; } else if (Double.isNaN(lowVoltageLimit) && isLowVoltageLimitDefaultSet) { double voltageLimit = voltageLevelDefaultLimits.get(voltageLevel.getId()).getLowVoltageLimit() + (isLowVoltageLimitModificationSet ? voltageLevelModificationLimits.get(voltageLevel.getId()).getLowVoltageLimit() : 0.); @@ -144,30 +150,34 @@ private static void setLowVoltageLimit(List specificVoltag newLowVoltageLimit = voltageLimit; } specificVoltageLimits.add(new VoltageLimitOverride(voltageLevel.getId(), VoltageLimitType.LOW_VOLTAGE_LIMIT, false, newLowVoltageLimit)); - counterMissingVoltageLimits.increment(); if (isLowVoltageLimitModificationSet) { - counterVoltageLimitModifications.increment(); + return CountVoltageLimit.DEFAULT; + } else { + return CountVoltageLimit.BOTH; } + } else { + return CountVoltageLimit.NONE; } } - private static void setHighVoltageLimit(List specificVoltageLimits, - final MutableInt counterMissingVoltageLimits, - final MutableInt counterVoltageLimitModifications, - Map voltageLevelModificationLimits, - Map voltageLevelDefaultLimits, - boolean isHighVoltageLimitModificationSet, - boolean isHighVoltageLimitDefaultSet, - VoltageLevel voltageLevel) { + private static CountVoltageLimit generateHighVoltageLimit(List specificVoltageLimits, + Map voltageLevelModificationLimits, + Map voltageLevelDefaultLimits, + boolean isHighVoltageLimitModificationSet, + boolean isHighVoltageLimitDefaultSet, + VoltageLevel voltageLevel) { if (!Double.isNaN(voltageLevel.getHighVoltageLimit()) && isHighVoltageLimitModificationSet) { specificVoltageLimits.add(new VoltageLimitOverride(voltageLevel.getId(), VoltageLimitType.HIGH_VOLTAGE_LIMIT, true, voltageLevelModificationLimits.get(voltageLevel.getId()).getHighVoltageLimit())); - counterVoltageLimitModifications.increment(); + return CountVoltageLimit.MODIFICATION; } else if (Double.isNaN(voltageLevel.getHighVoltageLimit()) && isHighVoltageLimitDefaultSet) { specificVoltageLimits.add(new VoltageLimitOverride(voltageLevel.getId(), VoltageLimitType.HIGH_VOLTAGE_LIMIT, false, voltageLevelDefaultLimits.get(voltageLevel.getId()).getHighVoltageLimit() + (isHighVoltageLimitModificationSet ? voltageLevelModificationLimits.get(voltageLevel.getId()).getHighVoltageLimit() : 0.))); - counterMissingVoltageLimits.increment(); if (isHighVoltageLimitModificationSet) { - counterVoltageLimitModifications.increment(); + return CountVoltageLimit.BOTH; + } else { + return CountVoltageLimit.DEFAULT; } + } else { + return CountVoltageLimit.NONE; } } @@ -298,4 +308,13 @@ private double computeRelativeVoltageLevel(final double initialVoltageLimit, @Nu return (override.isRelative() ? initialVoltageLimit : 0.0) + override.getLimit(); } } + + private enum CountVoltageLimit { + NONE, DEFAULT, MODIFICATION, BOTH; + + public CountVoltageLimit merge(@NonNull CountVoltageLimit other) { + final int merge = this.ordinal() | other.ordinal(); + return Arrays.stream(CountVoltageLimit.values()).filter(cvl -> cvl.ordinal() == merge).findAny().orElseThrow(); + } + } } diff --git a/src/test/resources/reporter_buildOpenReacParameters.json b/src/test/resources/reporter_buildOpenReacParameters.json index 333c099c..76408d10 100644 --- a/src/test/resources/reporter_buildOpenReacParameters.json +++ b/src/test/resources/reporter_buildOpenReacParameters.json @@ -103,7 +103,7 @@ "reportKey": "missingVoltageLimits", "values": { "nbMissingVoltageLimits": { - "value": 4 + "value": 3 }, "reportSeverity": { "value": "INFO", @@ -119,7 +119,7 @@ "type": "SEVERITY" }, "nbVoltageLimitModifications": { - "value": 0 + "value": 2 } } } @@ -130,8 +130,8 @@ "dics": { "default": { "voltageLimitModifications": "Voltage limits of ${nbVoltageLimitModifications} voltage levels have been modified according to user input.", - "VoltageInit": "VoltageInit", "OpenReacParameters": "OpenReac parameters", + "VoltageInit": "VoltageInit", "missingVoltageLimits": "Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.", "voltageLimitModified": "One or two voltage limits of voltage level ${voltageLevelId} have been replaced and/or modified: low voltage limit = ${newLowVoltageLimit} kV, high voltage limit = ${newHighVoltageLimit} kV (initial values: low voltage limit = ${initialLowVoltageLimit} kV, high voltage limit = ${initialHighVoltage} kV)." } diff --git a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json index f99ba077..66f6489a 100644 --- a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json +++ b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json @@ -144,7 +144,7 @@ "reportKey": "missingVoltageLimits", "values": { "nbMissingVoltageLimits": { - "value": 4 + "value": 3 }, "reportSeverity": { "value": "INFO", @@ -160,7 +160,7 @@ "type": "SEVERITY" }, "nbVoltageLimitModifications": { - "value": 8 + "value": 4 } } } diff --git a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json index b9062df9..fe0e5763 100644 --- a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json +++ b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json @@ -131,7 +131,7 @@ "type": "SEVERITY" }, "nbVoltageLimitModifications": { - "value": 4 + "value": 3 } } } diff --git a/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json b/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json index 060cbd8f..3e1a0927 100644 --- a/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json +++ b/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json @@ -132,7 +132,7 @@ "reportKey": "missingVoltageLimits", "values": { "nbMissingVoltageLimits": { - "value": 4 + "value": 3 }, "reportSeverity": { "value": "INFO", @@ -148,7 +148,7 @@ "type": "SEVERITY" }, "nbVoltageLimitModifications": { - "value": 8 + "value": 4 } } } From da02c0c7043e5ca1d76a610dd56e3ec0a45feca4 Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Fri, 5 Apr 2024 17:21:06 +0200 Subject: [PATCH 31/53] review --- .../VoltageInitParametersService.java | 14 ++-- .../reporter_buildOpenReacParameters.json | 50 ++++---------- ...dOpenReacParameters_caseRelativeFalse.json | 66 +++++-------------- ...ldOpenReacParameters_caseRelativeTrue.json | 50 ++++---------- ...ReacParameters_withLimitModifications.json | 66 +++++-------------- 5 files changed, 66 insertions(+), 180 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index 5a8cc89e..e7e604b5 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -258,12 +258,10 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, final double initialHighVoltage = voltageLevel.getHighVoltageLimit(); reporter.report(Report.builder() .withKey("voltageLimitModified") - .withDefaultMessage("One or two voltage limits of voltage level ${voltageLevelId} have been replaced and/or modified: low voltage limit = ${newLowVoltageLimit}\u202FkV, high voltage limit = ${newHighVoltageLimit}\u202FkV (initial values: low voltage limit = ${initialLowVoltageLimit}\u202FkV, high voltage limit = ${initialHighVoltage}\u202FkV).") + .withDefaultMessage("Voltage limits of ${voltageLevelId} modified: low voltage limit = ${initialLowVoltageLimit}\u202FkV → ${newLowVoltageLimit}\u202FkV, high voltage limit = ${initialHighVoltage}\u202FkV → ${newHighVoltageLimit}\u202FkV") .withTypedValue("voltageLevelId", voltageLevel.getId(), TypedValue.VOLTAGE_LEVEL) - .withTypedValue("newLowVoltageLimit", computeRelativeVoltageLevel(initialLowVoltageLimit, voltageLimits.get(VoltageLimitType.LOW_VOLTAGE_LIMIT)), TypedValue.VOLTAGE) - .withTypedValue("newHighVoltageLimit", computeRelativeVoltageLevel(initialHighVoltage, voltageLimits.get(VoltageLimitType.HIGH_VOLTAGE_LIMIT)), TypedValue.VOLTAGE) - .withTypedValue("initialLowVoltageLimit", initialLowVoltageLimit, TypedValue.VOLTAGE) - .withTypedValue("initialHighVoltage", initialHighVoltage, TypedValue.VOLTAGE) + .withTypedValue("lowVoltageLimit", computeRelativeVoltageLevel(initialLowVoltageLimit, voltageLimits.get(VoltageLimitType.LOW_VOLTAGE_LIMIT)), TypedValue.VOLTAGE) + .withTypedValue("highVoltageLimit", computeRelativeVoltageLevel(initialHighVoltage, voltageLimits.get(VoltageLimitType.HIGH_VOLTAGE_LIMIT)), TypedValue.VOLTAGE) .withSeverity(TypedValue.TRACE_SEVERITY) .build()); }); @@ -301,11 +299,11 @@ private List toEquipmentIdsList(UUID networkUuid, String variantId, List return new ArrayList<>(ids); } - private double computeRelativeVoltageLevel(final double initialVoltageLimit, @Nullable final VoltageLimitOverride override) { + private String computeRelativeVoltageLevel(final double initialVoltageLimit, @Nullable final VoltageLimitOverride override) { if (override == null) { - return initialVoltageLimit; + return initialVoltageLimit + "\u202FkV"; } else { - return (override.isRelative() ? initialVoltageLimit : 0.0) + override.getLimit(); + return initialVoltageLimit + "\u202FkV → " + (override.isRelative() ? initialVoltageLimit : 0.0) + override.getLimit() + "\u202FkV"; } } diff --git a/src/test/resources/reporter_buildOpenReacParameters.json b/src/test/resources/reporter_buildOpenReacParameters.json index 76408d10..2782345e 100644 --- a/src/test/resources/reporter_buildOpenReacParameters.json +++ b/src/test/resources/reporter_buildOpenReacParameters.json @@ -15,10 +15,6 @@ { "reportKey": "voltageLimitModified", "values": { - "initialLowVoltageLimit": { - "value": 10.0, - "type": "VOLTAGE" - }, "voltageLevelId": { "value": "VLHV2", "type": "VOLTAGE_LEVEL" @@ -27,16 +23,12 @@ "value": "TRACE", "type": "SEVERITY" }, - "newHighVoltageLimit": { - "value": 10.0, - "type": "VOLTAGE" - }, - "initialHighVoltage": { - "value": "NaN", + "highVoltageLimit": { + "value": "NaN kV → 0.010.0 kV", "type": "VOLTAGE" }, - "newLowVoltageLimit": { - "value": 10.0, + "lowVoltageLimit": { + "value": "10.0 kV", "type": "VOLTAGE" } } @@ -44,10 +36,6 @@ { "reportKey": "voltageLimitModified", "values": { - "initialLowVoltageLimit": { - "value": "NaN", - "type": "VOLTAGE" - }, "voltageLevelId": { "value": "VLHV1", "type": "VOLTAGE_LEVEL" @@ -56,16 +44,12 @@ "value": "TRACE", "type": "SEVERITY" }, - "newHighVoltageLimit": { - "value": 20.0, + "highVoltageLimit": { + "value": "20.0 kV", "type": "VOLTAGE" }, - "initialHighVoltage": { - "value": 20.0, - "type": "VOLTAGE" - }, - "newLowVoltageLimit": { - "value": 5.0, + "lowVoltageLimit": { + "value": "NaN kV → 0.05.0 kV", "type": "VOLTAGE" } } @@ -73,10 +57,6 @@ { "reportKey": "voltageLimitModified", "values": { - "initialLowVoltageLimit": { - "value": "NaN", - "type": "VOLTAGE" - }, "voltageLevelId": { "value": "VLLOAD", "type": "VOLTAGE_LEVEL" @@ -85,16 +65,12 @@ "value": "TRACE", "type": "SEVERITY" }, - "newHighVoltageLimit": { - "value": 88.0, - "type": "VOLTAGE" - }, - "initialHighVoltage": { - "value": "NaN", + "highVoltageLimit": { + "value": "NaN kV → 0.088.0 kV", "type": "VOLTAGE" }, - "newLowVoltageLimit": { - "value": 44.0, + "lowVoltageLimit": { + "value": "NaN kV → 0.044.0 kV", "type": "VOLTAGE" } } @@ -133,7 +109,7 @@ "OpenReacParameters": "OpenReac parameters", "VoltageInit": "VoltageInit", "missingVoltageLimits": "Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.", - "voltageLimitModified": "One or two voltage limits of voltage level ${voltageLevelId} have been replaced and/or modified: low voltage limit = ${newLowVoltageLimit} kV, high voltage limit = ${newHighVoltageLimit} kV (initial values: low voltage limit = ${initialLowVoltageLimit} kV, high voltage limit = ${initialHighVoltage} kV)." + "voltageLimitModified": "Voltage limits of ${voltageLevelId} modified: low voltage limit = ${initialLowVoltageLimit} kV → ${newLowVoltageLimit} kV, high voltage limit = ${initialHighVoltage} kV → ${newHighVoltageLimit} kV" } } } diff --git a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json index 66f6489a..8a1a7b84 100644 --- a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json +++ b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json @@ -27,10 +27,6 @@ { "reportKey": "voltageLimitModified", "values": { - "initialLowVoltageLimit": { - "value": 10.0, - "type": "VOLTAGE" - }, "voltageLevelId": { "value": "VLHV2", "type": "VOLTAGE_LEVEL" @@ -39,16 +35,12 @@ "value": "TRACE", "type": "SEVERITY" }, - "newHighVoltageLimit": { - "value": 20.0, - "type": "VOLTAGE" - }, - "initialHighVoltage": { - "value": "NaN", + "highVoltageLimit": { + "value": "NaN kV → 0.020.0 kV", "type": "VOLTAGE" }, - "newLowVoltageLimit": { - "value": 0.0, + "lowVoltageLimit": { + "value": "10.0 kV → 10.0-10.0 kV", "type": "VOLTAGE" } } @@ -56,10 +48,6 @@ { "reportKey": "voltageLimitModified", "values": { - "initialLowVoltageLimit": { - "value": "NaN", - "type": "VOLTAGE" - }, "voltageLevelId": { "value": "VLHV1", "type": "VOLTAGE_LEVEL" @@ -68,16 +56,12 @@ "value": "TRACE", "type": "SEVERITY" }, - "newHighVoltageLimit": { - "value": 30.0, - "type": "VOLTAGE" - }, - "initialHighVoltage": { - "value": 20.0, + "highVoltageLimit": { + "value": "20.0 kV → 20.010.0 kV", "type": "VOLTAGE" }, - "newLowVoltageLimit": { - "value": 0.0, + "lowVoltageLimit": { + "value": "NaN kV → 0.00.0 kV", "type": "VOLTAGE" } } @@ -85,10 +69,6 @@ { "reportKey": "voltageLimitModified", "values": { - "initialLowVoltageLimit": { - "value": 10.0, - "type": "VOLTAGE" - }, "voltageLevelId": { "value": "VLGEN", "type": "VOLTAGE_LEVEL" @@ -97,16 +77,12 @@ "value": "TRACE", "type": "SEVERITY" }, - "newHighVoltageLimit": { - "value": 30.0, - "type": "VOLTAGE" - }, - "initialHighVoltage": { - "value": 20.0, + "highVoltageLimit": { + "value": "20.0 kV → 20.010.0 kV", "type": "VOLTAGE" }, - "newLowVoltageLimit": { - "value": 0.0, + "lowVoltageLimit": { + "value": "10.0 kV → 10.0-10.0 kV", "type": "VOLTAGE" } } @@ -114,10 +90,6 @@ { "reportKey": "voltageLimitModified", "values": { - "initialLowVoltageLimit": { - "value": "NaN", - "type": "VOLTAGE" - }, "voltageLevelId": { "value": "VLLOAD", "type": "VOLTAGE_LEVEL" @@ -126,16 +98,12 @@ "value": "TRACE", "type": "SEVERITY" }, - "newHighVoltageLimit": { - "value": 20.0, - "type": "VOLTAGE" - }, - "initialHighVoltage": { - "value": "NaN", + "highVoltageLimit": { + "value": "NaN kV → 0.020.0 kV", "type": "VOLTAGE" }, - "newLowVoltageLimit": { - "value": 0.0, + "lowVoltageLimit": { + "value": "NaN kV → 0.00.0 kV", "type": "VOLTAGE" } } @@ -175,7 +143,7 @@ "OpenReacParameters": "OpenReac parameters", "VoltageInit": "VoltageInit", "missingVoltageLimits": "Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.", - "voltageLimitModified": "One or two voltage limits of voltage level ${voltageLevelId} have been replaced and/or modified: low voltage limit = ${newLowVoltageLimit} kV, high voltage limit = ${newHighVoltageLimit} kV (initial values: low voltage limit = ${initialLowVoltageLimit} kV, high voltage limit = ${initialHighVoltage} kV)." + "voltageLimitModified": "Voltage limits of ${voltageLevelId} modified: low voltage limit = ${initialLowVoltageLimit} kV → ${newLowVoltageLimit} kV, high voltage limit = ${initialHighVoltage} kV → ${newHighVoltageLimit} kV" } } } diff --git a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json index fe0e5763..0de7a132 100644 --- a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json +++ b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json @@ -27,10 +27,6 @@ { "reportKey": "voltageLimitModified", "values": { - "initialLowVoltageLimit": { - "value": 10.0, - "type": "VOLTAGE" - }, "voltageLevelId": { "value": "VLHV2", "type": "VOLTAGE_LEVEL" @@ -39,16 +35,12 @@ "value": "TRACE", "type": "SEVERITY" }, - "newHighVoltageLimit": { - "value": "NaN", - "type": "VOLTAGE" - }, - "initialHighVoltage": { - "value": "NaN", + "highVoltageLimit": { + "value": "NaN kV", "type": "VOLTAGE" }, - "newLowVoltageLimit": { - "value": 0.0, + "lowVoltageLimit": { + "value": "10.0 kV → 10.0-10.0 kV", "type": "VOLTAGE" } } @@ -56,10 +48,6 @@ { "reportKey": "voltageLimitModified", "values": { - "initialLowVoltageLimit": { - "value": "NaN", - "type": "VOLTAGE" - }, "voltageLevelId": { "value": "VLHV1", "type": "VOLTAGE_LEVEL" @@ -68,16 +56,12 @@ "value": "TRACE", "type": "SEVERITY" }, - "newHighVoltageLimit": { - "value": 30.0, + "highVoltageLimit": { + "value": "20.0 kV → 20.010.0 kV", "type": "VOLTAGE" }, - "initialHighVoltage": { - "value": 20.0, - "type": "VOLTAGE" - }, - "newLowVoltageLimit": { - "value": "NaN", + "lowVoltageLimit": { + "value": "NaN kV", "type": "VOLTAGE" } } @@ -85,10 +69,6 @@ { "reportKey": "voltageLimitModified", "values": { - "initialLowVoltageLimit": { - "value": 10.0, - "type": "VOLTAGE" - }, "voltageLevelId": { "value": "VLGEN", "type": "VOLTAGE_LEVEL" @@ -97,16 +77,12 @@ "value": "TRACE", "type": "SEVERITY" }, - "newHighVoltageLimit": { - "value": 30.0, - "type": "VOLTAGE" - }, - "initialHighVoltage": { - "value": 20.0, + "highVoltageLimit": { + "value": "20.0 kV → 20.010.0 kV", "type": "VOLTAGE" }, - "newLowVoltageLimit": { - "value": 0.0, + "lowVoltageLimit": { + "value": "10.0 kV → 10.0-10.0 kV", "type": "VOLTAGE" } } @@ -146,7 +122,7 @@ "OpenReacParameters": "OpenReac parameters", "VoltageInit": "VoltageInit", "missingVoltageLimits": "Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.", - "voltageLimitModified": "One or two voltage limits of voltage level ${voltageLevelId} have been replaced and/or modified: low voltage limit = ${newLowVoltageLimit} kV, high voltage limit = ${newHighVoltageLimit} kV (initial values: low voltage limit = ${initialLowVoltageLimit} kV, high voltage limit = ${initialHighVoltage} kV)." + "voltageLimitModified": "Voltage limits of ${voltageLevelId} modified: low voltage limit = ${initialLowVoltageLimit} kV → ${newLowVoltageLimit} kV, high voltage limit = ${initialHighVoltage} kV → ${newHighVoltageLimit} kV" } } } diff --git a/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json b/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json index 3e1a0927..493bc5a0 100644 --- a/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json +++ b/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json @@ -15,10 +15,6 @@ { "reportKey": "voltageLimitModified", "values": { - "initialLowVoltageLimit": { - "value": 10.0, - "type": "VOLTAGE" - }, "voltageLevelId": { "value": "VLHV2", "type": "VOLTAGE_LEVEL" @@ -27,16 +23,12 @@ "value": "TRACE", "type": "SEVERITY" }, - "newHighVoltageLimit": { - "value": 8.0, - "type": "VOLTAGE" - }, - "initialHighVoltage": { - "value": "NaN", + "highVoltageLimit": { + "value": "NaN kV → 0.08.0 kV", "type": "VOLTAGE" }, - "newLowVoltageLimit": { - "value": 9.0, + "lowVoltageLimit": { + "value": "10.0 kV → 10.0-1.0 kV", "type": "VOLTAGE" } } @@ -44,10 +36,6 @@ { "reportKey": "voltageLimitModified", "values": { - "initialLowVoltageLimit": { - "value": "NaN", - "type": "VOLTAGE" - }, "voltageLevelId": { "value": "VLHV1", "type": "VOLTAGE_LEVEL" @@ -56,16 +44,12 @@ "value": "TRACE", "type": "SEVERITY" }, - "newHighVoltageLimit": { - "value": 18.0, - "type": "VOLTAGE" - }, - "initialHighVoltage": { - "value": 20.0, + "highVoltageLimit": { + "value": "20.0 kV → 20.0-2.0 kV", "type": "VOLTAGE" }, - "newLowVoltageLimit": { - "value": 4.0, + "lowVoltageLimit": { + "value": "NaN kV → 0.04.0 kV", "type": "VOLTAGE" } } @@ -73,10 +57,6 @@ { "reportKey": "voltageLimitModified", "values": { - "initialLowVoltageLimit": { - "value": 10.0, - "type": "VOLTAGE" - }, "voltageLevelId": { "value": "VLGEN", "type": "VOLTAGE_LEVEL" @@ -85,16 +65,12 @@ "value": "TRACE", "type": "SEVERITY" }, - "newHighVoltageLimit": { - "value": 18.0, - "type": "VOLTAGE" - }, - "initialHighVoltage": { - "value": 20.0, + "highVoltageLimit": { + "value": "20.0 kV → 20.0-2.0 kV", "type": "VOLTAGE" }, - "newLowVoltageLimit": { - "value": 9.0, + "lowVoltageLimit": { + "value": "10.0 kV → 10.0-1.0 kV", "type": "VOLTAGE" } } @@ -102,10 +78,6 @@ { "reportKey": "voltageLimitModified", "values": { - "initialLowVoltageLimit": { - "value": "NaN", - "type": "VOLTAGE" - }, "voltageLevelId": { "value": "VLLOAD", "type": "VOLTAGE_LEVEL" @@ -114,16 +86,12 @@ "value": "TRACE", "type": "SEVERITY" }, - "newHighVoltageLimit": { - "value": 86.0, - "type": "VOLTAGE" - }, - "initialHighVoltage": { - "value": "NaN", + "highVoltageLimit": { + "value": "NaN kV → 0.086.0 kV", "type": "VOLTAGE" }, - "newLowVoltageLimit": { - "value": 43.0, + "lowVoltageLimit": { + "value": "NaN kV → 0.043.0 kV", "type": "VOLTAGE" } } @@ -162,7 +130,7 @@ "OpenReacParameters": "OpenReac parameters", "VoltageInit": "VoltageInit", "missingVoltageLimits": "Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.", - "voltageLimitModified": "One or two voltage limits of voltage level ${voltageLevelId} have been replaced and/or modified: low voltage limit = ${newLowVoltageLimit} kV, high voltage limit = ${newHighVoltageLimit} kV (initial values: low voltage limit = ${initialLowVoltageLimit} kV, high voltage limit = ${initialHighVoltage} kV)." + "voltageLimitModified": "Voltage limits of ${voltageLevelId} modified: low voltage limit = ${initialLowVoltageLimit} kV → ${newLowVoltageLimit} kV, high voltage limit = ${initialHighVoltage} kV → ${newHighVoltageLimit} kV" } } } From 6b0ac318ba438a7f8d2b212ec867c9f6b20f4114 Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Fri, 5 Apr 2024 17:56:40 +0200 Subject: [PATCH 32/53] try to fix counter --- .../VoltageInitParametersService.java | 15 ++++++--- .../service/parameters/ParametersTest.java | 32 ++++++++++++++++++- 2 files changed, 42 insertions(+), 5 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index e7e604b5..fff3af0b 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -10,6 +10,7 @@ import java.util.concurrent.TimeUnit; import java.util.stream.Collectors; +import com.google.common.annotations.VisibleForTesting; import com.powsybl.commons.reporter.Report; import com.powsybl.commons.reporter.Reporter; import com.powsybl.commons.reporter.TypedValue; @@ -307,12 +308,18 @@ private String computeRelativeVoltageLevel(final double initialVoltageLimit, @Nu } } - private enum CountVoltageLimit { + @VisibleForTesting + enum CountVoltageLimit { NONE, DEFAULT, MODIFICATION, BOTH; - public CountVoltageLimit merge(@NonNull CountVoltageLimit other) { - final int merge = this.ordinal() | other.ordinal(); - return Arrays.stream(CountVoltageLimit.values()).filter(cvl -> cvl.ordinal() == merge).findAny().orElseThrow(); + public CountVoltageLimit merge(@NonNull final CountVoltageLimit other) { + if (this == BOTH || other == BOTH || this == DEFAULT && other == MODIFICATION || this == MODIFICATION && other == DEFAULT) { + return BOTH; + } else if (this == NONE) { + return other; + } else { // other == NONE + return this; + } } } } diff --git a/src/test/java/org/gridsuite/voltageinit/server/service/parameters/ParametersTest.java b/src/test/java/org/gridsuite/voltageinit/server/service/parameters/ParametersTest.java index fb8853b0..6bf82208 100644 --- a/src/test/java/org/gridsuite/voltageinit/server/service/parameters/ParametersTest.java +++ b/src/test/java/org/gridsuite/voltageinit/server/service/parameters/ParametersTest.java @@ -18,14 +18,18 @@ import com.powsybl.openreac.parameters.input.VoltageLimitOverride; import com.powsybl.openreac.parameters.input.VoltageLimitOverride.VoltageLimitType; import lombok.extern.slf4j.Slf4j; +import org.apache.commons.lang3.tuple.Triple; import org.assertj.core.api.Condition; import org.assertj.core.api.ListAssert; +import org.assertj.core.api.SoftAssertions; +import org.assertj.core.api.junit.jupiter.SoftAssertionsExtension; import org.gridsuite.voltageinit.server.dto.parameters.FilterEquipments; import org.gridsuite.voltageinit.server.dto.parameters.IdentifiableAttributes; import org.gridsuite.voltageinit.server.entities.parameters.FilterEquipmentsEmbeddable; import org.gridsuite.voltageinit.server.entities.parameters.VoltageInitParametersEntity; import org.gridsuite.voltageinit.server.entities.parameters.VoltageLimitEntity; import org.gridsuite.voltageinit.server.service.VoltageInitRunContext; +import org.gridsuite.voltageinit.server.service.parameters.VoltageInitParametersService.CountVoltageLimit; import org.gridsuite.voltageinit.server.util.VoltageLimitParameterType; import org.gridsuite.voltageinit.utils.TestUtils; import org.junit.jupiter.api.BeforeEach; @@ -58,7 +62,7 @@ import static org.assertj.core.condition.VerboseCondition.verboseCondition; import static org.mockito.BDDMockito.given; -@ExtendWith({ MockitoExtension.class }) +@ExtendWith({ MockitoExtension.class, SoftAssertionsExtension.class }) @SpringBootTest @DirtiesContext @AutoConfigureTestEntityManager @@ -213,4 +217,30 @@ void testsBuildSpecificVoltageLimitsCaseRelativeFalse() throws Exception { // getLimit: The low voltage limit must be impacted by the modification of the value .containsOnlyOnce(new VoltageLimitOverride("VLHV1", VoltageLimitType.LOW_VOLTAGE_LIMIT, false, 0.0)); } + + @DisplayName("CountVoltageLimit.merge()") + @Test + void testCountVoltageLimitMerge(final SoftAssertions softly) { + List.of( + Triple.ofNonNull(CountVoltageLimit.NONE, CountVoltageLimit.NONE, CountVoltageLimit.NONE), + Triple.ofNonNull(CountVoltageLimit.NONE, CountVoltageLimit.DEFAULT, CountVoltageLimit.DEFAULT), + Triple.ofNonNull(CountVoltageLimit.NONE, CountVoltageLimit.MODIFICATION, CountVoltageLimit.MODIFICATION), + Triple.ofNonNull(CountVoltageLimit.NONE, CountVoltageLimit.BOTH, CountVoltageLimit.BOTH), + + Triple.ofNonNull(CountVoltageLimit.DEFAULT, CountVoltageLimit.NONE, CountVoltageLimit.DEFAULT), + Triple.ofNonNull(CountVoltageLimit.DEFAULT, CountVoltageLimit.DEFAULT, CountVoltageLimit.DEFAULT), + Triple.ofNonNull(CountVoltageLimit.DEFAULT, CountVoltageLimit.MODIFICATION, CountVoltageLimit.BOTH), + Triple.ofNonNull(CountVoltageLimit.DEFAULT, CountVoltageLimit.BOTH, CountVoltageLimit.BOTH), + + Triple.ofNonNull(CountVoltageLimit.MODIFICATION, CountVoltageLimit.NONE, CountVoltageLimit.MODIFICATION), + Triple.ofNonNull(CountVoltageLimit.MODIFICATION, CountVoltageLimit.DEFAULT, CountVoltageLimit.BOTH), + Triple.ofNonNull(CountVoltageLimit.MODIFICATION, CountVoltageLimit.MODIFICATION, CountVoltageLimit.MODIFICATION), + Triple.ofNonNull(CountVoltageLimit.MODIFICATION, CountVoltageLimit.BOTH, CountVoltageLimit.BOTH), + + Triple.ofNonNull(CountVoltageLimit.BOTH, CountVoltageLimit.NONE, CountVoltageLimit.BOTH), + Triple.ofNonNull(CountVoltageLimit.BOTH, CountVoltageLimit.DEFAULT, CountVoltageLimit.BOTH), + Triple.ofNonNull(CountVoltageLimit.BOTH, CountVoltageLimit.MODIFICATION, CountVoltageLimit.BOTH), + Triple.ofNonNull(CountVoltageLimit.BOTH, CountVoltageLimit.BOTH, CountVoltageLimit.BOTH) + ).forEach(tpl -> softly.assertThat(tpl.getLeft().merge(tpl.getMiddle())).as(tpl.getLeft() + " + " + tpl.getMiddle()).isSameAs(tpl.getRight())); + } } From 98f993620b7de1f9125cbca0f5eb7d2f30971161 Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Mon, 8 Apr 2024 12:53:57 +0200 Subject: [PATCH 33/53] review --- .../service/parameters/VoltageInitParametersService.java | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index fff3af0b..7eac1fb3 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -99,6 +99,8 @@ private Map resolveVoltageLevelLimits(VoltageInitRun return voltageLevelLimits; } + @SuppressWarnings({"EnumSwitchStatementWhichMissesCases", "java:S131"}) + // it's wanted to not have a case for NONE in switch, as we do nothing in this case private static void fillSpecificVoltageLimits(List specificVoltageLimits, final MutableInt counterMissingVoltageLimits, final MutableInt counterVoltageLimitModifications, @@ -111,8 +113,9 @@ private static void fillSpecificVoltageLimits(List specifi boolean isLowVoltageLimitDefaultSet = voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) && voltageLevelDefaultLimits.get(voltageLevel.getId()).getLowVoltageLimit() != null; boolean isHighVoltageLimitDefaultSet = voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) && voltageLevelDefaultLimits.get(voltageLevel.getId()).getHighVoltageLimit() != null; - switch (generateLowVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isLowVoltageLimitModificationSet, isLowVoltageLimitDefaultSet, voltageLevel, voltageLevelsIdsRestricted) - .merge(generateHighVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isHighVoltageLimitModificationSet, isHighVoltageLimitDefaultSet, voltageLevel))) { + final CountVoltageLimit counterToIncrement = generateLowVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isLowVoltageLimitModificationSet, isLowVoltageLimitDefaultSet, voltageLevel, voltageLevelsIdsRestricted) + .merge(generateHighVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isHighVoltageLimitModificationSet, isHighVoltageLimitDefaultSet, voltageLevel)); + switch (counterToIncrement) { case DEFAULT -> counterMissingVoltageLimits.increment(); case MODIFICATION -> counterVoltageLimitModifications.increment(); case BOTH -> { From 50c62ff62f3fb372006b3bc41f99616c80620227 Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Mon, 8 Apr 2024 15:27:48 +0200 Subject: [PATCH 34/53] fix log --- .../server/service/parameters/VoltageInitParametersService.java | 2 +- src/test/resources/reporter_buildOpenReacParameters.json | 2 +- .../reporter_buildOpenReacParameters_caseRelativeFalse.json | 2 +- .../reporter_buildOpenReacParameters_caseRelativeTrue.json | 2 +- ...reporter_buildOpenReacParameters_withLimitModifications.json | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index 7eac1fb3..50d722fd 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -262,7 +262,7 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, final double initialHighVoltage = voltageLevel.getHighVoltageLimit(); reporter.report(Report.builder() .withKey("voltageLimitModified") - .withDefaultMessage("Voltage limits of ${voltageLevelId} modified: low voltage limit = ${initialLowVoltageLimit}\u202FkV → ${newLowVoltageLimit}\u202FkV, high voltage limit = ${initialHighVoltage}\u202FkV → ${newHighVoltageLimit}\u202FkV") + .withDefaultMessage("Voltage limits of ${voltageLevelId} modified: low voltage limit = ${lowVoltageLimit}, high voltage limit = ${highVoltageLimit}") .withTypedValue("voltageLevelId", voltageLevel.getId(), TypedValue.VOLTAGE_LEVEL) .withTypedValue("lowVoltageLimit", computeRelativeVoltageLevel(initialLowVoltageLimit, voltageLimits.get(VoltageLimitType.LOW_VOLTAGE_LIMIT)), TypedValue.VOLTAGE) .withTypedValue("highVoltageLimit", computeRelativeVoltageLevel(initialHighVoltage, voltageLimits.get(VoltageLimitType.HIGH_VOLTAGE_LIMIT)), TypedValue.VOLTAGE) diff --git a/src/test/resources/reporter_buildOpenReacParameters.json b/src/test/resources/reporter_buildOpenReacParameters.json index 2782345e..97eb643a 100644 --- a/src/test/resources/reporter_buildOpenReacParameters.json +++ b/src/test/resources/reporter_buildOpenReacParameters.json @@ -109,7 +109,7 @@ "OpenReacParameters": "OpenReac parameters", "VoltageInit": "VoltageInit", "missingVoltageLimits": "Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.", - "voltageLimitModified": "Voltage limits of ${voltageLevelId} modified: low voltage limit = ${initialLowVoltageLimit} kV → ${newLowVoltageLimit} kV, high voltage limit = ${initialHighVoltage} kV → ${newHighVoltageLimit} kV" + "voltageLimitModified": "Voltage limits of ${voltageLevelId} modified: low voltage limit = ${lowVoltageLimit}, high voltage limit = ${highVoltageLimit}" } } } diff --git a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json index 8a1a7b84..d82fb798 100644 --- a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json +++ b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json @@ -143,7 +143,7 @@ "OpenReacParameters": "OpenReac parameters", "VoltageInit": "VoltageInit", "missingVoltageLimits": "Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.", - "voltageLimitModified": "Voltage limits of ${voltageLevelId} modified: low voltage limit = ${initialLowVoltageLimit} kV → ${newLowVoltageLimit} kV, high voltage limit = ${initialHighVoltage} kV → ${newHighVoltageLimit} kV" + "voltageLimitModified": "Voltage limits of ${voltageLevelId} modified: low voltage limit = ${lowVoltageLimit}, high voltage limit = ${highVoltageLimit}" } } } diff --git a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json index 0de7a132..5cb33919 100644 --- a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json +++ b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json @@ -122,7 +122,7 @@ "OpenReacParameters": "OpenReac parameters", "VoltageInit": "VoltageInit", "missingVoltageLimits": "Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.", - "voltageLimitModified": "Voltage limits of ${voltageLevelId} modified: low voltage limit = ${initialLowVoltageLimit} kV → ${newLowVoltageLimit} kV, high voltage limit = ${initialHighVoltage} kV → ${newHighVoltageLimit} kV" + "voltageLimitModified": "Voltage limits of ${voltageLevelId} modified: low voltage limit = ${lowVoltageLimit}, high voltage limit = ${highVoltageLimit}" } } } diff --git a/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json b/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json index 493bc5a0..1b260f2f 100644 --- a/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json +++ b/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json @@ -130,7 +130,7 @@ "OpenReacParameters": "OpenReac parameters", "VoltageInit": "VoltageInit", "missingVoltageLimits": "Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.", - "voltageLimitModified": "Voltage limits of ${voltageLevelId} modified: low voltage limit = ${initialLowVoltageLimit} kV → ${newLowVoltageLimit} kV, high voltage limit = ${initialHighVoltage} kV → ${newHighVoltageLimit} kV" + "voltageLimitModified": "Voltage limits of ${voltageLevelId} modified: low voltage limit = ${lowVoltageLimit}, high voltage limit = ${highVoltageLimit}" } } } From 9473f45ff3cc4229535a234eb850d93b6b37d137 Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Mon, 8 Apr 2024 16:09:07 +0200 Subject: [PATCH 35/53] hum... something is wrong with counters... --- .../VoltageInitParametersService.java | 21 +- .../service/parameters/ParametersTest.java | 56 +++- ...voltage_levels_for_S3VL1_S4VL1_S4VL2.xiidm | 256 ++++++++++++++++++ ...orter_fourSubstations_noVoltageLimits.json | 115 ++++++++ 4 files changed, 437 insertions(+), 11 deletions(-) create mode 100644 src/test/resources/fourSubstations_no_voltage_levels_for_S3VL1_S4VL1_S4VL2.xiidm create mode 100644 src/test/resources/reporter_fourSubstations_noVoltageLimits.json diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index 50d722fd..c5d33ba8 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -113,15 +113,15 @@ private static void fillSpecificVoltageLimits(List specifi boolean isLowVoltageLimitDefaultSet = voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) && voltageLevelDefaultLimits.get(voltageLevel.getId()).getLowVoltageLimit() != null; boolean isHighVoltageLimitDefaultSet = voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) && voltageLevelDefaultLimits.get(voltageLevel.getId()).getHighVoltageLimit() != null; - final CountVoltageLimit counterToIncrement = generateLowVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isLowVoltageLimitModificationSet, isLowVoltageLimitDefaultSet, voltageLevel, voltageLevelsIdsRestricted) - .merge(generateHighVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isHighVoltageLimitModificationSet, isHighVoltageLimitDefaultSet, voltageLevel)); - switch (counterToIncrement) { - case DEFAULT -> counterMissingVoltageLimits.increment(); - case MODIFICATION -> counterVoltageLimitModifications.increment(); - case BOTH -> { - counterMissingVoltageLimits.increment(); - counterVoltageLimitModifications.increment(); - } + final CountVoltageLimit counterToIncrement1 = generateLowVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isLowVoltageLimitModificationSet, isLowVoltageLimitDefaultSet, voltageLevel, voltageLevelsIdsRestricted); + final CountVoltageLimit counterToIncrement2 = generateHighVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isHighVoltageLimitModificationSet, isHighVoltageLimitDefaultSet, voltageLevel); + if ((counterToIncrement1 == CountVoltageLimit.DEFAULT || counterToIncrement1 == CountVoltageLimit.BOTH) || + (counterToIncrement2 == CountVoltageLimit.DEFAULT || counterToIncrement2 == CountVoltageLimit.BOTH)) { + counterMissingVoltageLimits.increment(); + } + if ((counterToIncrement1 == CountVoltageLimit.MODIFICATION || counterToIncrement1 == CountVoltageLimit.BOTH) || + (counterToIncrement2 == CountVoltageLimit.MODIFICATION || counterToIncrement2 == CountVoltageLimit.BOTH)) { + counterVoltageLimitModifications.increment(); } } @@ -311,6 +311,9 @@ private String computeRelativeVoltageLevel(final double initialVoltageLimit, @Nu } } + /** + * We count modifications per substation only once in {@link #filterService}, not twice + */ @VisibleForTesting enum CountVoltageLimit { NONE, DEFAULT, MODIFICATION, BOTH; diff --git a/src/test/java/org/gridsuite/voltageinit/server/service/parameters/ParametersTest.java b/src/test/java/org/gridsuite/voltageinit/server/service/parameters/ParametersTest.java index 6bf82208..c1b7023c 100644 --- a/src/test/java/org/gridsuite/voltageinit/server/service/parameters/ParametersTest.java +++ b/src/test/java/org/gridsuite/voltageinit/server/service/parameters/ParametersTest.java @@ -7,6 +7,7 @@ package org.gridsuite.voltageinit.server.service.parameters; import com.fasterxml.jackson.databind.ObjectMapper; +import com.powsybl.commons.reporter.ReporterModel; import com.powsybl.iidm.network.IdentifiableType; import com.powsybl.iidm.network.Network; import com.powsybl.iidm.network.VariantManagerConstants; @@ -36,6 +37,7 @@ import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mockito; import org.mockito.junit.jupiter.MockitoExtension; import org.skyscreamer.jsonassert.Customization; import org.skyscreamer.jsonassert.JSONAssert; @@ -47,10 +49,12 @@ import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.boot.test.mock.mockito.MockBean; -import org.springframework.test.annotation.DirtiesContext; import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.annotation.Transactional; +import java.io.InputStream; +import java.io.StringWriter; +import java.io.Writer; import java.util.List; import java.util.Objects; import java.util.UUID; @@ -64,7 +68,6 @@ @ExtendWith({ MockitoExtension.class, SoftAssertionsExtension.class }) @SpringBootTest -@DirtiesContext @AutoConfigureTestEntityManager @Transactional(propagation = Propagation.REQUIRES_NEW) @Slf4j @@ -218,6 +221,55 @@ void testsBuildSpecificVoltageLimitsCaseRelativeFalse() throws Exception { .containsOnlyOnce(new VoltageLimitOverride("VLHV1", VoltageLimitType.LOW_VOLTAGE_LIMIT, false, 0.0)); } + @DisplayName("buildSpecificVoltageLimits: fourSubstations study") + @Test + void testsBuildSpecificVoltageLimitsWithFourSubstationStudy() throws Exception { + Mockito.reset(networkStoreService, filterService); //don't use @BeforeEach setup() situation + + try (final InputStream data = this.getClass().getClassLoader().getResourceAsStream("fourSubstations_no_voltage_levels_for_S3VL1_S4VL1_S4VL2.xiidm")) { + network = Network.read("fourSubstations.xiidm", data); + } + final UUID networkUuid = UUID.randomUUID(); + final String variantId = UUID.randomUUID().toString(); + network.getVariantManager().cloneVariant(VariantManagerConstants.INITIAL_VARIANT_ID, variantId); + network.getVariantManager().setWorkingVariant(variantId); + given(networkStoreService.getNetwork(networkUuid, PreloadingStrategy.COLLECTION)).willReturn(network); + + final UUID filterUuidS3VL1 = UUID.randomUUID(); + final String filterIdS3VL1 = "FILTER_S3VL1"; + final UUID filterUuidS4VL1 = UUID.randomUUID(); + final String filterIdS4VL1 = "FILTER_S4VL1"; + final UUID filterUuidS4VL2 = UUID.randomUUID(); + final String filterIdS4VL2 = "FILTER_S4VL2"; + given(filterService.exportFilters(List.of(filterUuidS3VL1), networkUuid, variantId)).willReturn(List.of( + new FilterEquipments(filterUuidS3VL1, filterIdS3VL1, List.of(new IdentifiableAttributes("S3VL1", IdentifiableType.VOLTAGE_LEVEL, null)), List.of()) + )); + given(filterService.exportFilters(List.of(filterUuidS4VL1), networkUuid, variantId)).willReturn(List.of( + new FilterEquipments(filterUuidS4VL1, filterIdS4VL1, List.of(new IdentifiableAttributes("S4VL1", IdentifiableType.VOLTAGE_LEVEL, null)), List.of()) + )); + given(filterService.exportFilters(List.of(filterUuidS4VL2), networkUuid, variantId)).willReturn(List.of( + new FilterEquipments(filterUuidS4VL2, filterIdS4VL2, List.of(new IdentifiableAttributes("S4VL2", IdentifiableType.VOLTAGE_LEVEL, null)), List.of()) + )); + + final VoltageLimitEntity vl1 = new VoltageLimitEntity(null, 50.0, 500.0, 0, VoltageLimitParameterType.DEFAULT, List.of(new FilterEquipmentsEmbeddable(filterUuidS3VL1, filterIdS3VL1))); + final VoltageLimitEntity vl2 = new VoltageLimitEntity(null, 60.0, 600.0, 0, VoltageLimitParameterType.DEFAULT, List.of(new FilterEquipmentsEmbeddable(filterUuidS4VL1, filterIdS4VL1))); + final VoltageLimitEntity vl3 = new VoltageLimitEntity(null, 70.0, 700.0, 0, VoltageLimitParameterType.DEFAULT, List.of(new FilterEquipmentsEmbeddable(filterUuidS4VL2, filterIdS4VL2))); + final VoltageLimitEntity vl4 = new VoltageLimitEntity(null, -20.0, 10.0, 0, VoltageLimitParameterType.MODIFICATION, List.of(new FilterEquipmentsEmbeddable(filterUuidS3VL1, filterIdS3VL1))); + final VoltageInitParametersEntity voltageInitParameters = entityManager.persistFlushFind( + new VoltageInitParametersEntity(null, null, "", List.of(vl1, vl2, vl3, vl4), null, null, null) + ); + + final VoltageInitRunContext context = new VoltageInitRunContext(networkUuid, variantId, null, REPORT_UUID, null, "", "", voltageInitParameters.getId()); + final OpenReacParameters openReacParameters = voltageInitParametersService.buildOpenReacParameters(context, network); + if (log.isDebugEnabled()) { + log.debug("openReac build parameters report: {}", mapper.writeValueAsString(context.getRootReporter())); + final Writer writer = new StringWriter(); + ((ReporterModel) context.getRootReporter()).export(writer); + log.debug("openReac report: {}", writer.toString()); + } + JSONAssert.assertEquals("build parameters logs", TestUtils.resourceToString("reporter_fourSubstations_noVoltageLimits.json"), mapper.writeValueAsString(context.getRootReporter()), REPORTER_COMPARATOR); + } + @DisplayName("CountVoltageLimit.merge()") @Test void testCountVoltageLimitMerge(final SoftAssertions softly) { diff --git a/src/test/resources/fourSubstations_no_voltage_levels_for_S3VL1_S4VL1_S4VL2.xiidm b/src/test/resources/fourSubstations_no_voltage_levels_for_S3VL1_S4VL1_S4VL2.xiidm new file mode 100644 index 00000000..d3c2ff78 --- /dev/null +++ b/src/test/resources/fourSubstations_no_voltage_levels_for_S3VL1_S4VL1_S4VL2.xiidm @@ -0,0 +1,256 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/test/resources/reporter_fourSubstations_noVoltageLimits.json b/src/test/resources/reporter_fourSubstations_noVoltageLimits.json new file mode 100644 index 00000000..97616ed4 --- /dev/null +++ b/src/test/resources/reporter_fourSubstations_noVoltageLimits.json @@ -0,0 +1,115 @@ +{ + "version": "1.0", + "reportTree": { + "taskKey": "VoltageInit", + "subReporters": [ + { + "taskKey": "OpenReacParameters", + "taskValues": { + "parameters_id": { + "value": "11111111-1111-1111-11111111111111111", + "type": "ID" + } + }, + "reports": [ + { + "reportKey": "voltageLimitModified", + "values": { + "voltageLevelId": { + "value": "S4VL1", + "type": "VOLTAGE_LEVEL" + }, + "reportSeverity": { + "value": "TRACE", + "type": "SEVERITY" + }, + "highVoltageLimit": { + "value": "NaN kV → 0.0600.0 kV", + "type": "VOLTAGE" + }, + "lowVoltageLimit": { + "value": "NaN kV → 0.060.0 kV", + "type": "VOLTAGE" + } + } + }, + { + "reportKey": "voltageLimitModified", + "values": { + "voltageLevelId": { + "value": "S4VL2", + "type": "VOLTAGE_LEVEL" + }, + "reportSeverity": { + "value": "TRACE", + "type": "SEVERITY" + }, + "highVoltageLimit": { + "value": "NaN kV → 0.0700.0 kV", + "type": "VOLTAGE" + }, + "lowVoltageLimit": { + "value": "NaN kV → 0.070.0 kV", + "type": "VOLTAGE" + } + } + }, + { + "reportKey": "voltageLimitModified", + "values": { + "voltageLevelId": { + "value": "S3VL1", + "type": "VOLTAGE_LEVEL" + }, + "reportSeverity": { + "value": "TRACE", + "type": "SEVERITY" + }, + "highVoltageLimit": { + "value": "NaN kV → 0.0510.0 kV", + "type": "VOLTAGE" + }, + "lowVoltageLimit": { + "value": "NaN kV → 0.030.0 kV", + "type": "VOLTAGE" + } + } + }, + { + "reportKey": "missingVoltageLimits", + "values": { + "nbMissingVoltageLimits": { + "value": 3 + }, + "reportSeverity": { + "value": "INFO", + "type": "SEVERITY" + } + } + }, + { + "reportKey": "voltageLimitModifications", + "values": { + "reportSeverity": { + "value": "INFO", + "type": "SEVERITY" + }, + "nbVoltageLimitModifications": { + "value": 1 + } + } + } + ] + } + ] + }, + "dics": { + "default": { + "voltageLimitModifications": "Voltage limits of ${nbVoltageLimitModifications} voltage levels have been modified according to user input.", + "OpenReacParameters": "OpenReac parameters", + "VoltageInit": "VoltageInit", + "missingVoltageLimits": "Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.", + "voltageLimitModified": "Voltage limits of ${voltageLevelId} modified: low voltage limit = ${lowVoltageLimit}, high voltage limit = ${highVoltageLimit}" + } + } +} From 4a3d669826f1c4cdaa0d21a7bcc352f59a7e8d0a Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Mon, 8 Apr 2024 17:07:49 +0200 Subject: [PATCH 36/53] fix logline message --- .../parameters/VoltageInitParametersService.java | 9 ++++++--- .../reporter_buildOpenReacParameters.json | 8 ++++---- ...uildOpenReacParameters_caseRelativeFalse.json | 16 ++++++++-------- ...buildOpenReacParameters_caseRelativeTrue.json | 12 ++++++------ ...penReacParameters_withLimitModifications.json | 16 ++++++++-------- ...reporter_fourSubstations_noVoltageLimits.json | 12 ++++++------ 6 files changed, 38 insertions(+), 35 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index c5d33ba8..c1736001 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -303,11 +303,14 @@ private List toEquipmentIdsList(UUID networkUuid, String variantId, List return new ArrayList<>(ids); } - private String computeRelativeVoltageLevel(final double initialVoltageLimit, @Nullable final VoltageLimitOverride override) { + private static String voltageToString(double voltage) { + return Double.isNaN(voltage) ? Double.toString(voltage) : voltage + "\u202FkV"; + } + private static String computeRelativeVoltageLevel(final double initialVoltageLimit, @Nullable final VoltageLimitOverride override) { if (override == null) { - return initialVoltageLimit + "\u202FkV"; + return voltageToString(initialVoltageLimit); } else { - return initialVoltageLimit + "\u202FkV → " + (override.isRelative() ? initialVoltageLimit : 0.0) + override.getLimit() + "\u202FkV"; + return voltageToString(initialVoltageLimit) + " → " + voltageToString((override.isRelative() ? initialVoltageLimit : 0.0) + override.getLimit()); } } diff --git a/src/test/resources/reporter_buildOpenReacParameters.json b/src/test/resources/reporter_buildOpenReacParameters.json index 97eb643a..5ef78bc7 100644 --- a/src/test/resources/reporter_buildOpenReacParameters.json +++ b/src/test/resources/reporter_buildOpenReacParameters.json @@ -24,7 +24,7 @@ "type": "SEVERITY" }, "highVoltageLimit": { - "value": "NaN kV → 0.010.0 kV", + "value": "NaN → 10.0 kV", "type": "VOLTAGE" }, "lowVoltageLimit": { @@ -49,7 +49,7 @@ "type": "VOLTAGE" }, "lowVoltageLimit": { - "value": "NaN kV → 0.05.0 kV", + "value": "NaN → 5.0 kV", "type": "VOLTAGE" } } @@ -66,11 +66,11 @@ "type": "SEVERITY" }, "highVoltageLimit": { - "value": "NaN kV → 0.088.0 kV", + "value": "NaN → 88.0 kV", "type": "VOLTAGE" }, "lowVoltageLimit": { - "value": "NaN kV → 0.044.0 kV", + "value": "NaN → 44.0 kV", "type": "VOLTAGE" } } diff --git a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json index d82fb798..77a05b2d 100644 --- a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json +++ b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json @@ -36,11 +36,11 @@ "type": "SEVERITY" }, "highVoltageLimit": { - "value": "NaN kV → 0.020.0 kV", + "value": "NaN → 20.0 kV", "type": "VOLTAGE" }, "lowVoltageLimit": { - "value": "10.0 kV → 10.0-10.0 kV", + "value": "10.0 kV → 0.0 kV", "type": "VOLTAGE" } } @@ -57,11 +57,11 @@ "type": "SEVERITY" }, "highVoltageLimit": { - "value": "20.0 kV → 20.010.0 kV", + "value": "20.0 kV → 30.0 kV", "type": "VOLTAGE" }, "lowVoltageLimit": { - "value": "NaN kV → 0.00.0 kV", + "value": "NaN → 0.0 kV", "type": "VOLTAGE" } } @@ -78,11 +78,11 @@ "type": "SEVERITY" }, "highVoltageLimit": { - "value": "20.0 kV → 20.010.0 kV", + "value": "20.0 kV → 30.0 kV", "type": "VOLTAGE" }, "lowVoltageLimit": { - "value": "10.0 kV → 10.0-10.0 kV", + "value": "10.0 kV → 0.0 kV", "type": "VOLTAGE" } } @@ -99,11 +99,11 @@ "type": "SEVERITY" }, "highVoltageLimit": { - "value": "NaN kV → 0.020.0 kV", + "value": "NaN → 20.0 kV", "type": "VOLTAGE" }, "lowVoltageLimit": { - "value": "NaN kV → 0.00.0 kV", + "value": "NaN → 0.0 kV", "type": "VOLTAGE" } } diff --git a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json index 5cb33919..26eaa1c2 100644 --- a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json +++ b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json @@ -36,11 +36,11 @@ "type": "SEVERITY" }, "highVoltageLimit": { - "value": "NaN kV", + "value": "NaN", "type": "VOLTAGE" }, "lowVoltageLimit": { - "value": "10.0 kV → 10.0-10.0 kV", + "value": "10.0 kV → 0.0 kV", "type": "VOLTAGE" } } @@ -57,11 +57,11 @@ "type": "SEVERITY" }, "highVoltageLimit": { - "value": "20.0 kV → 20.010.0 kV", + "value": "20.0 kV → 30.0 kV", "type": "VOLTAGE" }, "lowVoltageLimit": { - "value": "NaN kV", + "value": "NaN", "type": "VOLTAGE" } } @@ -78,11 +78,11 @@ "type": "SEVERITY" }, "highVoltageLimit": { - "value": "20.0 kV → 20.010.0 kV", + "value": "20.0 kV → 30.0 kV", "type": "VOLTAGE" }, "lowVoltageLimit": { - "value": "10.0 kV → 10.0-10.0 kV", + "value": "10.0 kV → 0.0 kV", "type": "VOLTAGE" } } diff --git a/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json b/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json index 1b260f2f..1bdde9cf 100644 --- a/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json +++ b/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json @@ -24,11 +24,11 @@ "type": "SEVERITY" }, "highVoltageLimit": { - "value": "NaN kV → 0.08.0 kV", + "value": "NaN → 8.0 kV", "type": "VOLTAGE" }, "lowVoltageLimit": { - "value": "10.0 kV → 10.0-1.0 kV", + "value": "10.0 kV → 9.0 kV", "type": "VOLTAGE" } } @@ -45,11 +45,11 @@ "type": "SEVERITY" }, "highVoltageLimit": { - "value": "20.0 kV → 20.0-2.0 kV", + "value": "20.0 kV → 18.0 kV", "type": "VOLTAGE" }, "lowVoltageLimit": { - "value": "NaN kV → 0.04.0 kV", + "value": "NaN → 4.0 kV", "type": "VOLTAGE" } } @@ -66,11 +66,11 @@ "type": "SEVERITY" }, "highVoltageLimit": { - "value": "20.0 kV → 20.0-2.0 kV", + "value": "20.0 kV → 18.0 kV", "type": "VOLTAGE" }, "lowVoltageLimit": { - "value": "10.0 kV → 10.0-1.0 kV", + "value": "10.0 kV → 9.0 kV", "type": "VOLTAGE" } } @@ -87,11 +87,11 @@ "type": "SEVERITY" }, "highVoltageLimit": { - "value": "NaN kV → 0.086.0 kV", + "value": "NaN → 86.0 kV", "type": "VOLTAGE" }, "lowVoltageLimit": { - "value": "NaN kV → 0.043.0 kV", + "value": "NaN → 43.0 kV", "type": "VOLTAGE" } } diff --git a/src/test/resources/reporter_fourSubstations_noVoltageLimits.json b/src/test/resources/reporter_fourSubstations_noVoltageLimits.json index 97616ed4..4c4cb544 100644 --- a/src/test/resources/reporter_fourSubstations_noVoltageLimits.json +++ b/src/test/resources/reporter_fourSubstations_noVoltageLimits.json @@ -24,11 +24,11 @@ "type": "SEVERITY" }, "highVoltageLimit": { - "value": "NaN kV → 0.0600.0 kV", + "value": "NaN → 600.0 kV", "type": "VOLTAGE" }, "lowVoltageLimit": { - "value": "NaN kV → 0.060.0 kV", + "value": "NaN → 60.0 kV", "type": "VOLTAGE" } } @@ -45,11 +45,11 @@ "type": "SEVERITY" }, "highVoltageLimit": { - "value": "NaN kV → 0.0700.0 kV", + "value": "NaN → 700.0 kV", "type": "VOLTAGE" }, "lowVoltageLimit": { - "value": "NaN kV → 0.070.0 kV", + "value": "NaN → 70.0 kV", "type": "VOLTAGE" } } @@ -66,11 +66,11 @@ "type": "SEVERITY" }, "highVoltageLimit": { - "value": "NaN kV → 0.0510.0 kV", + "value": "NaN → 510.0 kV", "type": "VOLTAGE" }, "lowVoltageLimit": { - "value": "NaN kV → 0.030.0 kV", + "value": "NaN → 30.0 kV", "type": "VOLTAGE" } } From 22b73d424709d6a967a3bb44e76501b2d1966b8e Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Mon, 8 Apr 2024 17:26:43 +0200 Subject: [PATCH 37/53] found it! --- .../service/parameters/VoltageInitParametersService.java | 5 +++-- src/test/resources/reporter_buildOpenReacParameters.json | 2 +- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index c1736001..5ea2747f 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -155,9 +155,9 @@ private static CountVoltageLimit generateLowVoltageLimit(List toEquipmentIdsList(UUID networkUuid, String variantId, List private static String voltageToString(double voltage) { return Double.isNaN(voltage) ? Double.toString(voltage) : voltage + "\u202FkV"; } + private static String computeRelativeVoltageLevel(final double initialVoltageLimit, @Nullable final VoltageLimitOverride override) { if (override == null) { return voltageToString(initialVoltageLimit); diff --git a/src/test/resources/reporter_buildOpenReacParameters.json b/src/test/resources/reporter_buildOpenReacParameters.json index 5ef78bc7..2d92903c 100644 --- a/src/test/resources/reporter_buildOpenReacParameters.json +++ b/src/test/resources/reporter_buildOpenReacParameters.json @@ -95,7 +95,7 @@ "type": "SEVERITY" }, "nbVoltageLimitModifications": { - "value": 2 + "value": 0 } } } From 5805e754904e78b4ba6416581d2e2200d3501641 Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Mon, 8 Apr 2024 17:29:11 +0200 Subject: [PATCH 38/53] checkstyle --- .../service/parameters/VoltageInitParametersService.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index 5ea2747f..07295f23 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -115,12 +115,12 @@ private static void fillSpecificVoltageLimits(List specifi final CountVoltageLimit counterToIncrement1 = generateLowVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isLowVoltageLimitModificationSet, isLowVoltageLimitDefaultSet, voltageLevel, voltageLevelsIdsRestricted); final CountVoltageLimit counterToIncrement2 = generateHighVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isHighVoltageLimitModificationSet, isHighVoltageLimitDefaultSet, voltageLevel); - if ((counterToIncrement1 == CountVoltageLimit.DEFAULT || counterToIncrement1 == CountVoltageLimit.BOTH) || - (counterToIncrement2 == CountVoltageLimit.DEFAULT || counterToIncrement2 == CountVoltageLimit.BOTH)) { + if (counterToIncrement1 == CountVoltageLimit.DEFAULT || counterToIncrement1 == CountVoltageLimit.BOTH || + counterToIncrement2 == CountVoltageLimit.DEFAULT || counterToIncrement2 == CountVoltageLimit.BOTH) { counterMissingVoltageLimits.increment(); } - if ((counterToIncrement1 == CountVoltageLimit.MODIFICATION || counterToIncrement1 == CountVoltageLimit.BOTH) || - (counterToIncrement2 == CountVoltageLimit.MODIFICATION || counterToIncrement2 == CountVoltageLimit.BOTH)) { + if (counterToIncrement1 == CountVoltageLimit.MODIFICATION || counterToIncrement1 == CountVoltageLimit.BOTH || + counterToIncrement2 == CountVoltageLimit.MODIFICATION || counterToIncrement2 == CountVoltageLimit.BOTH) { counterVoltageLimitModifications.increment(); } } From 0a96d373f9d25d72a9d77c29c9eedf6b7b5d0203 Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Mon, 8 Apr 2024 17:38:12 +0200 Subject: [PATCH 39/53] review --- .../server/service/VoltageInitRunContext.java | 9 ++------- .../voltageinit/server/service/VoltageInitService.java | 2 +- 2 files changed, 3 insertions(+), 8 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitRunContext.java b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitRunContext.java index cd6da2f6..06a91a43 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitRunContext.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitRunContext.java @@ -38,10 +38,10 @@ public class VoltageInitRunContext { private final UUID parametersUuid; - private final Map voltageLevelsIdsRestricted; + private final Map voltageLevelsIdsRestricted = new HashMap<>(); private final Reporter rootReporter; - public VoltageInitRunContext(UUID networkUuid, String variantId, String receiver, UUID reportUuid, String reporterId, String reportType, String userId, UUID parametersUuid, Map voltageLevelsIdsRestricted) { + public VoltageInitRunContext(UUID networkUuid, String variantId, String receiver, UUID reportUuid, String reporterId, String reportType, String userId, UUID parametersUuid) { this.networkUuid = Objects.requireNonNull(networkUuid); this.variantId = variantId; this.receiver = receiver; @@ -50,7 +50,6 @@ public VoltageInitRunContext(UUID networkUuid, String variantId, String receiver this.reportType = reportType; this.userId = userId; this.parametersUuid = parametersUuid; - this.voltageLevelsIdsRestricted = voltageLevelsIdsRestricted; if (this.reportUuid == null) { this.rootReporter = Reporter.NO_OP; } else { @@ -58,8 +57,4 @@ public VoltageInitRunContext(UUID networkUuid, String variantId, String receiver this.rootReporter = new ReporterModel(rootReporterId, rootReporterId); } } - - public VoltageInitRunContext(UUID networkUuid, String variantId, String receiver, UUID reportUuid, String reporterId, String reportType, String userId, UUID parametersUuid) { - this(networkUuid, variantId, receiver, reportUuid, reporterId, reportType, userId, parametersUuid, new HashMap<>()); - } } diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitService.java b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitService.java index 5332dc73..e37aff0a 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitService.java @@ -50,7 +50,7 @@ public VoltageInitService(NotificationService notificationService, } public UUID runAndSaveResult(UUID networkUuid, String variantId, String receiver, UUID reportUuid, String reporterId, String userId, String reportType, UUID parametersUuid) { - VoltageInitRunContext runContext = new VoltageInitRunContext(networkUuid, variantId, receiver, reportUuid, reporterId, reportType, userId, parametersUuid, new HashMap<>()); + VoltageInitRunContext runContext = new VoltageInitRunContext(networkUuid, variantId, receiver, reportUuid, reporterId, reportType, userId, parametersUuid); Objects.requireNonNull(runContext); var resultUuid = uuidGeneratorService.generate(); From 27f6583bd6903e02ff0a5bac8b499636efb12f1a Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Mon, 8 Apr 2024 17:45:39 +0200 Subject: [PATCH 40/53] review --- .../VoltageInitParametersService.java | 20 +++++++++---------- 1 file changed, 9 insertions(+), 11 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index 07295f23..6a0473a2 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -99,8 +99,6 @@ private Map resolveVoltageLevelLimits(VoltageInitRun return voltageLevelLimits; } - @SuppressWarnings({"EnumSwitchStatementWhichMissesCases", "java:S131"}) - // it's wanted to not have a case for NONE in switch, as we do nothing in this case private static void fillSpecificVoltageLimits(List specificVoltageLimits, final MutableInt counterMissingVoltageLimits, final MutableInt counterVoltageLimitModifications, @@ -113,14 +111,14 @@ private static void fillSpecificVoltageLimits(List specifi boolean isLowVoltageLimitDefaultSet = voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) && voltageLevelDefaultLimits.get(voltageLevel.getId()).getLowVoltageLimit() != null; boolean isHighVoltageLimitDefaultSet = voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) && voltageLevelDefaultLimits.get(voltageLevel.getId()).getHighVoltageLimit() != null; - final CountVoltageLimit counterToIncrement1 = generateLowVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isLowVoltageLimitModificationSet, isLowVoltageLimitDefaultSet, voltageLevel, voltageLevelsIdsRestricted); - final CountVoltageLimit counterToIncrement2 = generateHighVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isHighVoltageLimitModificationSet, isHighVoltageLimitDefaultSet, voltageLevel); - if (counterToIncrement1 == CountVoltageLimit.DEFAULT || counterToIncrement1 == CountVoltageLimit.BOTH || - counterToIncrement2 == CountVoltageLimit.DEFAULT || counterToIncrement2 == CountVoltageLimit.BOTH) { + final CountVoltageLimit counterToIncrementLow = generateLowVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isLowVoltageLimitModificationSet, isLowVoltageLimitDefaultSet, voltageLevel, voltageLevelsIdsRestricted); + final CountVoltageLimit counterToIncrementHigh = generateHighVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isHighVoltageLimitModificationSet, isHighVoltageLimitDefaultSet, voltageLevel); + if (counterToIncrementLow == CountVoltageLimit.DEFAULT || counterToIncrementLow == CountVoltageLimit.BOTH || + counterToIncrementHigh == CountVoltageLimit.DEFAULT || counterToIncrementHigh == CountVoltageLimit.BOTH) { counterMissingVoltageLimits.increment(); } - if (counterToIncrement1 == CountVoltageLimit.MODIFICATION || counterToIncrement1 == CountVoltageLimit.BOTH || - counterToIncrement2 == CountVoltageLimit.MODIFICATION || counterToIncrement2 == CountVoltageLimit.BOTH) { + if (counterToIncrementLow == CountVoltageLimit.MODIFICATION || counterToIncrementLow == CountVoltageLimit.BOTH || + counterToIncrementHigh == CountVoltageLimit.MODIFICATION || counterToIncrementHigh == CountVoltageLimit.BOTH) { counterVoltageLimitModifications.increment(); } } @@ -251,9 +249,9 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, (map, voltageLimitOverride) -> map .computeIfAbsent(voltageLimitOverride.getVoltageLevelId(), key -> new EnumMap<>(VoltageLimitType.class)) .put(voltageLimitOverride.getVoltageLimitType(), voltageLimitOverride), - (map, map2) -> map2.forEach((id, newLimits) -> map.merge(id, newLimits, (nl1, nl2) -> { - nl1.putAll(nl2); - return nl1; + (map, map2) -> map2.forEach((id, newLimits) -> map.merge(id, newLimits, (newLimit1, newLimit2) -> { + newLimit1.putAll(newLimit2); + return newLimit1; }) )) .forEach((id, voltageLimits) -> { From 3f94e7cdd01052653b11a4009fedb2225d5a8168 Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Tue, 9 Apr 2024 08:06:28 +0200 Subject: [PATCH 41/53] revert 5805e754904e78b4ba6416581d2e2200d3501641 --- .../server/service/VoltageInitRunContext.java | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitRunContext.java b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitRunContext.java index 06a91a43..cd6da2f6 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitRunContext.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitRunContext.java @@ -38,10 +38,10 @@ public class VoltageInitRunContext { private final UUID parametersUuid; - private final Map voltageLevelsIdsRestricted = new HashMap<>(); + private final Map voltageLevelsIdsRestricted; private final Reporter rootReporter; - public VoltageInitRunContext(UUID networkUuid, String variantId, String receiver, UUID reportUuid, String reporterId, String reportType, String userId, UUID parametersUuid) { + public VoltageInitRunContext(UUID networkUuid, String variantId, String receiver, UUID reportUuid, String reporterId, String reportType, String userId, UUID parametersUuid, Map voltageLevelsIdsRestricted) { this.networkUuid = Objects.requireNonNull(networkUuid); this.variantId = variantId; this.receiver = receiver; @@ -50,6 +50,7 @@ public VoltageInitRunContext(UUID networkUuid, String variantId, String receiver this.reportType = reportType; this.userId = userId; this.parametersUuid = parametersUuid; + this.voltageLevelsIdsRestricted = voltageLevelsIdsRestricted; if (this.reportUuid == null) { this.rootReporter = Reporter.NO_OP; } else { @@ -57,4 +58,8 @@ public VoltageInitRunContext(UUID networkUuid, String variantId, String receiver this.rootReporter = new ReporterModel(rootReporterId, rootReporterId); } } + + public VoltageInitRunContext(UUID networkUuid, String variantId, String receiver, UUID reportUuid, String reporterId, String reportType, String userId, UUID parametersUuid) { + this(networkUuid, variantId, receiver, reportUuid, reporterId, reportType, userId, parametersUuid, new HashMap<>()); + } } From 8301e9df1dee7a7be70bc5dc05824f9030f1e1b5 Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Tue, 9 Apr 2024 16:17:34 +0200 Subject: [PATCH 42/53] review Signed-off-by: Tristan Chuine --- .../server/service/VoltageInitRunContext.java | 27 ++----- .../service/VoltageInitWorkerService.java | 7 ++ .../VoltageInitParametersService.java | 80 +++++++++---------- .../service/parameters/ParametersTest.java | 31 +------ 4 files changed, 52 insertions(+), 93 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitRunContext.java b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitRunContext.java index cd6da2f6..1bcb6d78 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitRunContext.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitRunContext.java @@ -7,8 +7,9 @@ package org.gridsuite.voltageinit.server.service; import com.powsybl.commons.reporter.Reporter; -import com.powsybl.commons.reporter.ReporterModel; -import lombok.Data; +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.Setter; import java.util.HashMap; import java.util.Map; @@ -18,9 +19,9 @@ /** * @author Etienne Homer */ -@Data +@AllArgsConstructor +@Getter public class VoltageInitRunContext { - private static final String VOLTAGE_INIT_TYPE_REPORT = "VoltageInit"; private final UUID networkUuid; @@ -39,24 +40,10 @@ public class VoltageInitRunContext { private final UUID parametersUuid; private final Map voltageLevelsIdsRestricted; - private final Reporter rootReporter; + @Setter private Reporter rootReporter; public VoltageInitRunContext(UUID networkUuid, String variantId, String receiver, UUID reportUuid, String reporterId, String reportType, String userId, UUID parametersUuid, Map voltageLevelsIdsRestricted) { - this.networkUuid = Objects.requireNonNull(networkUuid); - this.variantId = variantId; - this.receiver = receiver; - this.reportUuid = reportUuid; - this.reporterId = reporterId; - this.reportType = reportType; - this.userId = userId; - this.parametersUuid = parametersUuid; - this.voltageLevelsIdsRestricted = voltageLevelsIdsRestricted; - if (this.reportUuid == null) { - this.rootReporter = Reporter.NO_OP; - } else { - final String rootReporterId = reporterId == null ? VOLTAGE_INIT_TYPE_REPORT : reporterId + "@" + reportType; - this.rootReporter = new ReporterModel(rootReporterId, rootReporterId); - } + this(Objects.requireNonNull(networkUuid), variantId, receiver, reportUuid, reporterId, reportType, userId, parametersUuid, voltageLevelsIdsRestricted, Reporter.NO_OP); } public VoltageInitRunContext(UUID networkUuid, String variantId, String receiver, UUID reportUuid, String reporterId, String reportType, String userId, UUID parametersUuid) { diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitWorkerService.java b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitWorkerService.java index 06022c3e..7d6ffb42 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitWorkerService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitWorkerService.java @@ -8,6 +8,8 @@ import com.google.common.collect.Sets; import com.powsybl.commons.PowsyblException; +import com.powsybl.commons.reporter.Reporter; +import com.powsybl.commons.reporter.ReporterModel; import com.powsybl.iidm.network.Bus; import com.powsybl.iidm.network.Network; import com.powsybl.iidm.network.VariantManagerConstants; @@ -54,6 +56,8 @@ public class VoltageInitWorkerService { private static final String ERROR = "error"; private static final String ERROR_DURING_VOLTAGE_PROFILE_INITIALISATION = "Error during voltage profile initialization"; + private static final String VOLTAGE_INIT_TYPE_REPORT = "VoltageInit"; + private final NetworkStoreService networkStoreService; private final NetworkModificationService networkModificationService; @@ -115,6 +119,9 @@ private Pair run(VoltageInitRunContext context, UUID re getNetwork(context.getNetworkUuid(), context.getVariantId())); if (context.getReportUuid() != null) { + String rootReporterId = context.getReporterId() == null ? VOLTAGE_INIT_TYPE_REPORT : context.getReporterId() + "@" + context.getReportType(); + Reporter rootReporter = new ReporterModel(rootReporterId, rootReporterId); + context.setRootReporter(rootReporter.createSubReporter(context.getReportType(), VOLTAGE_INIT_TYPE_REPORT, VOLTAGE_INIT_TYPE_REPORT, context.getReportUuid().toString())); // Delete any previous VoltageInit computation logs voltageInitObserver.observe("report.delete", () -> reportService.deleteReport(context.getReportUuid(), context.getReportType())); diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index 6a0473a2..6b5c0834 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -6,8 +6,10 @@ */ package org.gridsuite.voltageinit.server.service.parameters; +import java.text.DecimalFormat; import java.util.*; import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicReference; import java.util.stream.Collectors; import com.google.common.annotations.VisibleForTesting; @@ -20,7 +22,6 @@ import com.powsybl.openreac.parameters.input.VoltageLimitOverride; import com.powsybl.openreac.parameters.input.VoltageLimitOverride.VoltageLimitType; import com.powsybl.openreac.parameters.input.algo.ReactiveSlackBusesMode; -import lombok.NonNull; import org.apache.commons.lang3.mutable.MutableInt; import org.gridsuite.voltageinit.server.dto.parameters.FilterEquipments; import org.gridsuite.voltageinit.server.dto.parameters.IdentifiableAttributes; @@ -45,6 +46,7 @@ public class VoltageInitParametersService { private static final Logger LOGGER = LoggerFactory.getLogger(VoltageInitParametersService.class); + private static final DecimalFormat DF = new DecimalFormat("0.0"); private final FilterService filterService; @@ -111,25 +113,25 @@ private static void fillSpecificVoltageLimits(List specifi boolean isLowVoltageLimitDefaultSet = voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) && voltageLevelDefaultLimits.get(voltageLevel.getId()).getLowVoltageLimit() != null; boolean isHighVoltageLimitDefaultSet = voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) && voltageLevelDefaultLimits.get(voltageLevel.getId()).getHighVoltageLimit() != null; - final CountVoltageLimit counterToIncrementLow = generateLowVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isLowVoltageLimitModificationSet, isLowVoltageLimitDefaultSet, voltageLevel, voltageLevelsIdsRestricted); - final CountVoltageLimit counterToIncrementHigh = generateHighVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isHighVoltageLimitModificationSet, isHighVoltageLimitDefaultSet, voltageLevel); - if (counterToIncrementLow == CountVoltageLimit.DEFAULT || counterToIncrementLow == CountVoltageLimit.BOTH || - counterToIncrementHigh == CountVoltageLimit.DEFAULT || counterToIncrementHigh == CountVoltageLimit.BOTH) { + final CounterToIncrement counterToIncrementLow = generateLowVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isLowVoltageLimitModificationSet, isLowVoltageLimitDefaultSet, voltageLevel, voltageLevelsIdsRestricted); + final CounterToIncrement counterToIncrementHigh = generateHighVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isHighVoltageLimitModificationSet, isHighVoltageLimitDefaultSet, voltageLevel); + if (counterToIncrementLow == CounterToIncrement.DEFAULT || counterToIncrementLow == CounterToIncrement.BOTH || + counterToIncrementHigh == CounterToIncrement.DEFAULT || counterToIncrementHigh == CounterToIncrement.BOTH) { counterMissingVoltageLimits.increment(); } - if (counterToIncrementLow == CountVoltageLimit.MODIFICATION || counterToIncrementLow == CountVoltageLimit.BOTH || - counterToIncrementHigh == CountVoltageLimit.MODIFICATION || counterToIncrementHigh == CountVoltageLimit.BOTH) { + if (counterToIncrementLow == CounterToIncrement.MODIFICATION || counterToIncrementLow == CounterToIncrement.BOTH || + counterToIncrementHigh == CounterToIncrement.MODIFICATION || counterToIncrementHigh == CounterToIncrement.BOTH) { counterVoltageLimitModifications.increment(); } } - private static CountVoltageLimit generateLowVoltageLimit(List specificVoltageLimits, - Map voltageLevelModificationLimits, - Map voltageLevelDefaultLimits, - boolean isLowVoltageLimitModificationSet, - boolean isLowVoltageLimitDefaultSet, - VoltageLevel voltageLevel, - Map voltageLevelsIdsRestricted) { + private static CounterToIncrement generateLowVoltageLimit(List specificVoltageLimits, + Map voltageLevelModificationLimits, + Map voltageLevelDefaultLimits, + boolean isLowVoltageLimitModificationSet, + boolean isLowVoltageLimitDefaultSet, + VoltageLevel voltageLevel, + Map voltageLevelsIdsRestricted) { double newLowVoltageLimit; double lowVoltageLimit = voltageLevel.getLowVoltageLimit(); if (!Double.isNaN(lowVoltageLimit) && isLowVoltageLimitModificationSet) { @@ -141,7 +143,7 @@ private static CountVoltageLimit generateLowVoltageLimit(List specificVoltageLimits, - Map voltageLevelModificationLimits, - Map voltageLevelDefaultLimits, - boolean isHighVoltageLimitModificationSet, - boolean isHighVoltageLimitDefaultSet, - VoltageLevel voltageLevel) { + private static CounterToIncrement generateHighVoltageLimit(List specificVoltageLimits, + Map voltageLevelModificationLimits, + Map voltageLevelDefaultLimits, + boolean isHighVoltageLimitModificationSet, + boolean isHighVoltageLimitDefaultSet, + VoltageLevel voltageLevel) { if (!Double.isNaN(voltageLevel.getHighVoltageLimit()) && isHighVoltageLimitModificationSet) { specificVoltageLimits.add(new VoltageLimitOverride(voltageLevel.getId(), VoltageLimitType.HIGH_VOLTAGE_LIMIT, true, voltageLevelModificationLimits.get(voltageLevel.getId()).getHighVoltageLimit())); - return CountVoltageLimit.MODIFICATION; + return CounterToIncrement.MODIFICATION; } else if (Double.isNaN(voltageLevel.getHighVoltageLimit()) && isHighVoltageLimitDefaultSet) { specificVoltageLimits.add(new VoltageLimitOverride(voltageLevel.getId(), VoltageLimitType.HIGH_VOLTAGE_LIMIT, false, voltageLevelDefaultLimits.get(voltageLevel.getId()).getHighVoltageLimit() + (isHighVoltageLimitModificationSet ? voltageLevelModificationLimits.get(voltageLevel.getId()).getHighVoltageLimit() : 0.))); if (isHighVoltageLimitModificationSet) { - return CountVoltageLimit.BOTH; + return CounterToIncrement.BOTH; } else { - return CountVoltageLimit.DEFAULT; + return CounterToIncrement.DEFAULT; } } else { - return CountVoltageLimit.NONE; + return CounterToIncrement.NONE; } } @Transactional(readOnly = true) public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, Network network) { - final long startTime = System.nanoTime(); + AtomicReference startTime = new AtomicReference<>(System.nanoTime()); final Reporter reporter = context.getRootReporter().createSubReporter("OpenReacParameters", "OpenReac parameters", Map.of( "parameters_id", new TypedValue(Objects.toString(context.getParametersUuid()), "ID") )); @@ -214,7 +216,7 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, .toList()); network.getVoltageLevelStream() - .filter(voltageLevel -> voltageLevelDefaultLimits.keySet().contains(voltageLevel.getId()) || voltageLevelModificationLimits.keySet().contains(voltageLevel.getId())) + .filter(voltageLevel -> voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) || voltageLevelModificationLimits.containsKey(voltageLevel.getId())) .forEach(voltageLevel -> fillSpecificVoltageLimits(specificVoltageLimits, counterMissingVoltageLimits, counterVoltageLimitModifications, voltageLevelModificationLimits, voltageLevelDefaultLimits, @@ -283,7 +285,7 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, //The optimizer will attach reactive slack variables to all buses parameters.setReactiveSlackBusesMode(ReactiveSlackBusesMode.ALL); - LOGGER.info("Parameters built in {}s", TimeUnit.NANOSECONDS.toSeconds(System.nanoTime() - startTime)); + LOGGER.info("Parameters built in {}s", TimeUnit.NANOSECONDS.toSeconds(System.nanoTime() - startTime.get())); return parameters; } @@ -302,7 +304,7 @@ private List toEquipmentIdsList(UUID networkUuid, String variantId, List } private static String voltageToString(double voltage) { - return Double.isNaN(voltage) ? Double.toString(voltage) : voltage + "\u202FkV"; + return Double.isNaN(voltage) ? DF.format(voltage) : voltage + "\u202FkV"; } private static String computeRelativeVoltageLevel(final double initialVoltageLimit, @Nullable final VoltageLimitOverride override) { @@ -317,17 +319,7 @@ private static String computeRelativeVoltageLevel(final double initialVoltageLim * We count modifications per substation only once in {@link #filterService}, not twice */ @VisibleForTesting - enum CountVoltageLimit { - NONE, DEFAULT, MODIFICATION, BOTH; - - public CountVoltageLimit merge(@NonNull final CountVoltageLimit other) { - if (this == BOTH || other == BOTH || this == DEFAULT && other == MODIFICATION || this == MODIFICATION && other == DEFAULT) { - return BOTH; - } else if (this == NONE) { - return other; - } else { // other == NONE - return this; - } - } + enum CounterToIncrement { + NONE, DEFAULT, MODIFICATION, BOTH } } diff --git a/src/test/java/org/gridsuite/voltageinit/server/service/parameters/ParametersTest.java b/src/test/java/org/gridsuite/voltageinit/server/service/parameters/ParametersTest.java index c1b7023c..0f79a81e 100644 --- a/src/test/java/org/gridsuite/voltageinit/server/service/parameters/ParametersTest.java +++ b/src/test/java/org/gridsuite/voltageinit/server/service/parameters/ParametersTest.java @@ -19,10 +19,8 @@ import com.powsybl.openreac.parameters.input.VoltageLimitOverride; import com.powsybl.openreac.parameters.input.VoltageLimitOverride.VoltageLimitType; import lombok.extern.slf4j.Slf4j; -import org.apache.commons.lang3.tuple.Triple; import org.assertj.core.api.Condition; import org.assertj.core.api.ListAssert; -import org.assertj.core.api.SoftAssertions; import org.assertj.core.api.junit.jupiter.SoftAssertionsExtension; import org.gridsuite.voltageinit.server.dto.parameters.FilterEquipments; import org.gridsuite.voltageinit.server.dto.parameters.IdentifiableAttributes; @@ -30,7 +28,6 @@ import org.gridsuite.voltageinit.server.entities.parameters.VoltageInitParametersEntity; import org.gridsuite.voltageinit.server.entities.parameters.VoltageLimitEntity; import org.gridsuite.voltageinit.server.service.VoltageInitRunContext; -import org.gridsuite.voltageinit.server.service.parameters.VoltageInitParametersService.CountVoltageLimit; import org.gridsuite.voltageinit.server.util.VoltageLimitParameterType; import org.gridsuite.voltageinit.utils.TestUtils; import org.junit.jupiter.api.BeforeEach; @@ -150,6 +147,7 @@ private ListAssert testsBuildSpecificVoltageLimitsCommon(L new VoltageInitParametersEntity(null, null, "", voltageLimits, null, null, null) ); final VoltageInitRunContext context = new VoltageInitRunContext(NETWORK_UUID, VARIANT_ID_1, null, REPORT_UUID, null, "", "", voltageInitParameters.getId()); + context.setRootReporter(new ReporterModel("VoltageInit", "VoltageInit")); final OpenReacParameters openReacParameters = voltageInitParametersService.buildOpenReacParameters(context, network); log.debug("openReac build parameters report: {}", mapper.writeValueAsString(context.getRootReporter())); JSONAssert.assertEquals("build parameters logs", TestUtils.resourceToString(reportFilename), mapper.writeValueAsString(context.getRootReporter()), REPORTER_COMPARATOR); @@ -260,6 +258,7 @@ void testsBuildSpecificVoltageLimitsWithFourSubstationStudy() throws Exception { ); final VoltageInitRunContext context = new VoltageInitRunContext(networkUuid, variantId, null, REPORT_UUID, null, "", "", voltageInitParameters.getId()); + context.setRootReporter(new ReporterModel("VoltageInit", "VoltageInit")); final OpenReacParameters openReacParameters = voltageInitParametersService.buildOpenReacParameters(context, network); if (log.isDebugEnabled()) { log.debug("openReac build parameters report: {}", mapper.writeValueAsString(context.getRootReporter())); @@ -269,30 +268,4 @@ void testsBuildSpecificVoltageLimitsWithFourSubstationStudy() throws Exception { } JSONAssert.assertEquals("build parameters logs", TestUtils.resourceToString("reporter_fourSubstations_noVoltageLimits.json"), mapper.writeValueAsString(context.getRootReporter()), REPORTER_COMPARATOR); } - - @DisplayName("CountVoltageLimit.merge()") - @Test - void testCountVoltageLimitMerge(final SoftAssertions softly) { - List.of( - Triple.ofNonNull(CountVoltageLimit.NONE, CountVoltageLimit.NONE, CountVoltageLimit.NONE), - Triple.ofNonNull(CountVoltageLimit.NONE, CountVoltageLimit.DEFAULT, CountVoltageLimit.DEFAULT), - Triple.ofNonNull(CountVoltageLimit.NONE, CountVoltageLimit.MODIFICATION, CountVoltageLimit.MODIFICATION), - Triple.ofNonNull(CountVoltageLimit.NONE, CountVoltageLimit.BOTH, CountVoltageLimit.BOTH), - - Triple.ofNonNull(CountVoltageLimit.DEFAULT, CountVoltageLimit.NONE, CountVoltageLimit.DEFAULT), - Triple.ofNonNull(CountVoltageLimit.DEFAULT, CountVoltageLimit.DEFAULT, CountVoltageLimit.DEFAULT), - Triple.ofNonNull(CountVoltageLimit.DEFAULT, CountVoltageLimit.MODIFICATION, CountVoltageLimit.BOTH), - Triple.ofNonNull(CountVoltageLimit.DEFAULT, CountVoltageLimit.BOTH, CountVoltageLimit.BOTH), - - Triple.ofNonNull(CountVoltageLimit.MODIFICATION, CountVoltageLimit.NONE, CountVoltageLimit.MODIFICATION), - Triple.ofNonNull(CountVoltageLimit.MODIFICATION, CountVoltageLimit.DEFAULT, CountVoltageLimit.BOTH), - Triple.ofNonNull(CountVoltageLimit.MODIFICATION, CountVoltageLimit.MODIFICATION, CountVoltageLimit.MODIFICATION), - Triple.ofNonNull(CountVoltageLimit.MODIFICATION, CountVoltageLimit.BOTH, CountVoltageLimit.BOTH), - - Triple.ofNonNull(CountVoltageLimit.BOTH, CountVoltageLimit.NONE, CountVoltageLimit.BOTH), - Triple.ofNonNull(CountVoltageLimit.BOTH, CountVoltageLimit.DEFAULT, CountVoltageLimit.BOTH), - Triple.ofNonNull(CountVoltageLimit.BOTH, CountVoltageLimit.MODIFICATION, CountVoltageLimit.BOTH), - Triple.ofNonNull(CountVoltageLimit.BOTH, CountVoltageLimit.BOTH, CountVoltageLimit.BOTH) - ).forEach(tpl -> softly.assertThat(tpl.getLeft().merge(tpl.getMiddle())).as(tpl.getLeft() + " + " + tpl.getMiddle()).isSameAs(tpl.getRight())); - } } From 1a7f24de627cff17ab976c6c49759e021bda4e40 Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Tue, 9 Apr 2024 16:52:33 +0200 Subject: [PATCH 43/53] review (bis) --- .../server/service/VoltageInitWorkerService.java | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitWorkerService.java b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitWorkerService.java index 7d6ffb42..129c9ed7 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitWorkerService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitWorkerService.java @@ -118,10 +118,11 @@ private Pair run(VoltageInitRunContext context, UUID re Network network = voltageInitObserver.observe("network.load", () -> getNetwork(context.getNetworkUuid(), context.getVariantId())); + AtomicReference rootReporter = new AtomicReference<>(Reporter.NO_OP); if (context.getReportUuid() != null) { String rootReporterId = context.getReporterId() == null ? VOLTAGE_INIT_TYPE_REPORT : context.getReporterId() + "@" + context.getReportType(); - Reporter rootReporter = new ReporterModel(rootReporterId, rootReporterId); - context.setRootReporter(rootReporter.createSubReporter(context.getReportType(), VOLTAGE_INIT_TYPE_REPORT, VOLTAGE_INIT_TYPE_REPORT, context.getReportUuid().toString())); + rootReporter.set(new ReporterModel(rootReporterId, rootReporterId)); + context.setRootReporter(rootReporter.get().createSubReporter(context.getReportType(), VOLTAGE_INIT_TYPE_REPORT, VOLTAGE_INIT_TYPE_REPORT, context.getReportUuid().toString())); // Delete any previous VoltageInit computation logs voltageInitObserver.observe("report.delete", () -> reportService.deleteReport(context.getReportUuid(), context.getReportType())); @@ -129,7 +130,7 @@ private Pair run(VoltageInitRunContext context, UUID re CompletableFuture future = runVoltageInitAsync(context, network, resultUuid); if (context.getReportUuid() != null) { voltageInitObserver.observe("report.send", () -> - reportService.sendReport(context.getReportUuid(), context.getRootReporter())); + reportService.sendReport(context.getReportUuid(), rootReporter.get())); } return future == null ? Pair.of(network, null) : Pair.of(network, voltageInitObserver.observeRun("run", future::get)); From dbb6a390865128f894f78451bf2efe466501be46 Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Tue, 9 Apr 2024 17:06:37 +0200 Subject: [PATCH 44/53] review --- .../VoltageInitParametersService.java | 102 ++++++++++-------- ...dOpenReacParameters_caseRelativeFalse.json | 2 +- ...ldOpenReacParameters_caseRelativeTrue.json | 2 +- 3 files changed, 59 insertions(+), 47 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index 6b5c0834..ce15bd73 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -222,18 +222,7 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, voltageLevelModificationLimits, voltageLevelDefaultLimits, voltageLevel, context.getVoltageLevelsIdsRestricted())); - if (!context.getVoltageLevelsIdsRestricted().isEmpty()) { - reporter.report(Report.builder() - .withKey("restrictedVoltageLevels") - .withDefaultMessage("The modifications to the low limits for certain voltage levels have been restricted to avoid negative voltage limits: ${joinedVoltageLevelsIds}") - .withValue("joinedVoltageLevelsIds", context.getVoltageLevelsIdsRestricted() - .entrySet() - .stream() - .map(entry -> entry.getKey() + " : " + entry.getValue()) - .collect(Collectors.joining(", "))) - .withSeverity(TypedValue.WARN_SEVERITY) - .build()); - } + logRestrictedVoltageLevels(reporter, context.getVoltageLevelsIdsRestricted()); } constantQGenerators.addAll(toEquipmentIdsList(context.getNetworkUuid(), context.getVariantId(), voltageInitParameters.getConstantQGenerators())); @@ -245,7 +234,62 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, .addVariableTwoWindingsTransformers(variableTwoWindingsTransformers) .addVariableShuntCompensators(variableShuntCompensators); - parameters.getSpecificVoltageLimits() + logVoltageLimitsModified(reporter, network, parameters.getSpecificVoltageLimits()); + logFiltersCounters(reporter, counterMissingVoltageLimits, counterVoltageLimitModifications); + + //The optimizer will attach reactive slack variables to all buses + parameters.setReactiveSlackBusesMode(ReactiveSlackBusesMode.ALL); + + LOGGER.info("Parameters built in {}s", TimeUnit.NANOSECONDS.toSeconds(System.nanoTime() - startTime.get())); + return parameters; + } + + private List toEquipmentIdsList(UUID networkUuid, String variantId, List filters) { + if (filters == null || filters.isEmpty()) { + return List.of(); + } + List equipments = filterService.exportFilters(filters.stream().map(FilterEquipmentsEmbeddable::getFilterId).toList(), networkUuid, variantId); + Set ids = new HashSet<>(); + equipments.forEach(filterEquipment -> + filterEquipment.getIdentifiableAttributes().forEach(identifiableAttribute -> + ids.add(identifiableAttribute.getId()) + ) + ); + return new ArrayList<>(ids); + } + + private static void logRestrictedVoltageLevels(final Reporter reporter, final Map voltageLevelsIdsRestricted) { + if (!voltageLevelsIdsRestricted.isEmpty()) { + reporter.report(Report.builder() + .withKey("restrictedVoltageLevels") + .withDefaultMessage("The modifications to the low limits for certain voltage levels have been restricted to avoid negative voltage limits: ${joinedVoltageLevelsIds}") + .withValue("joinedVoltageLevelsIds", voltageLevelsIdsRestricted + .entrySet() + .stream() + .map(entry -> entry.getKey() + " : " + voltageToString(entry.getValue())) + .collect(Collectors.joining(", "))) + .withSeverity(TypedValue.WARN_SEVERITY) + .build()); + } + } + + private static void logFiltersCounters(final Reporter reporter, final MutableInt counterMissingVoltageLimits, final MutableInt counterVoltageLimitModifications) { + reporter.report(Report.builder() + .withKey("missingVoltageLimits") + .withDefaultMessage("Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.") + .withValue("nbMissingVoltageLimits", counterMissingVoltageLimits.longValue()) + .withSeverity(TypedValue.INFO_SEVERITY) + .build()); + reporter.report(Report.builder() + .withKey("voltageLimitModifications") + .withDefaultMessage("Voltage limits of ${nbVoltageLimitModifications} voltage levels have been modified according to user input.") + .withValue("nbVoltageLimitModifications", counterVoltageLimitModifications.longValue()) + .withSeverity(TypedValue.INFO_SEVERITY) + .build()); + } + + private static void logVoltageLimitsModified(final Reporter reporter, final Network network, final List specificVoltageLimits) { + specificVoltageLimits .stream() .collect(HashMap>::new, (map, voltageLimitOverride) -> map @@ -269,38 +313,6 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, .withSeverity(TypedValue.TRACE_SEVERITY) .build()); }); - reporter.report(Report.builder() - .withKey("missingVoltageLimits") - .withDefaultMessage("Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.") - .withValue("nbMissingVoltageLimits", counterMissingVoltageLimits.longValue()) - .withSeverity(TypedValue.INFO_SEVERITY) - .build()); - reporter.report(Report.builder() - .withKey("voltageLimitModifications") - .withDefaultMessage("Voltage limits of ${nbVoltageLimitModifications} voltage levels have been modified according to user input.") - .withValue("nbVoltageLimitModifications", counterVoltageLimitModifications.longValue()) - .withSeverity(TypedValue.INFO_SEVERITY) - .build()); - - //The optimizer will attach reactive slack variables to all buses - parameters.setReactiveSlackBusesMode(ReactiveSlackBusesMode.ALL); - - LOGGER.info("Parameters built in {}s", TimeUnit.NANOSECONDS.toSeconds(System.nanoTime() - startTime.get())); - return parameters; - } - - private List toEquipmentIdsList(UUID networkUuid, String variantId, List filters) { - if (filters == null || filters.isEmpty()) { - return List.of(); - } - List equipments = filterService.exportFilters(filters.stream().map(FilterEquipmentsEmbeddable::getFilterId).toList(), networkUuid, variantId); - Set ids = new HashSet<>(); - equipments.forEach(filterEquipment -> - filterEquipment.getIdentifiableAttributes().forEach(identifiableAttribute -> - ids.add(identifiableAttribute.getId()) - ) - ); - return new ArrayList<>(ids); } private static String voltageToString(double voltage) { diff --git a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json index 77a05b2d..8eec2557 100644 --- a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json +++ b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json @@ -20,7 +20,7 @@ "type": "SEVERITY" }, "joinedVoltageLevelsIds": { - "value": "VLHV2 : -10.0, VLHV1 : 0.0, VLGEN : -10.0, VLLOAD : 0.0" + "value": "VLHV2 : -10.0 kV, VLHV1 : 0.0 kV, VLGEN : -10.0 kV, VLLOAD : 0.0 kV" } } }, diff --git a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json index 26eaa1c2..abc131c3 100644 --- a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json +++ b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json @@ -20,7 +20,7 @@ "type": "SEVERITY" }, "joinedVoltageLevelsIds": { - "value": "VLHV2 : -10.0, VLGEN : -10.0" + "value": "VLHV2 : -10.0 kV, VLGEN : -10.0 kV" } } }, From 5e6bddad4c79e24e14aae4f12be27edfdbd3c507 Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Tue, 9 Apr 2024 18:54:15 +0200 Subject: [PATCH 45/53] optimize memory usage --- .../VoltageInitParametersService.java | 92 +++++++++---------- .../service/parameters/ParametersTest.java | 31 ++++++- 2 files changed, 76 insertions(+), 47 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index ce15bd73..9b5f1872 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -22,6 +22,7 @@ import com.powsybl.openreac.parameters.input.VoltageLimitOverride; import com.powsybl.openreac.parameters.input.VoltageLimitOverride.VoltageLimitType; import com.powsybl.openreac.parameters.input.algo.ReactiveSlackBusesMode; +import lombok.NonNull; import org.apache.commons.lang3.mutable.MutableInt; import org.gridsuite.voltageinit.server.dto.parameters.FilterEquipments; import org.gridsuite.voltageinit.server.dto.parameters.IdentifiableAttributes; @@ -101,28 +102,25 @@ private Map resolveVoltageLevelLimits(VoltageInitRun return voltageLevelLimits; } - private static void fillSpecificVoltageLimits(List specificVoltageLimits, - final MutableInt counterMissingVoltageLimits, - final MutableInt counterVoltageLimitModifications, - Map voltageLevelModificationLimits, - Map voltageLevelDefaultLimits, - VoltageLevel voltageLevel, - Map voltageLevelsIdsRestricted) { + private static CounterToIncrement fillSpecificVoltageLimits(final Reporter reporter, + LinkedList specificVoltageLimits, + Map voltageLevelModificationLimits, + Map voltageLevelDefaultLimits, + VoltageLevel voltageLevel, + Map voltageLevelsIdsRestricted) { boolean isLowVoltageLimitModificationSet = voltageLevelModificationLimits.containsKey(voltageLevel.getId()) && voltageLevelModificationLimits.get(voltageLevel.getId()).getLowVoltageLimit() != null; boolean isHighVoltageLimitModificationSet = voltageLevelModificationLimits.containsKey(voltageLevel.getId()) && voltageLevelModificationLimits.get(voltageLevel.getId()).getHighVoltageLimit() != null; boolean isLowVoltageLimitDefaultSet = voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) && voltageLevelDefaultLimits.get(voltageLevel.getId()).getLowVoltageLimit() != null; boolean isHighVoltageLimitDefaultSet = voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) && voltageLevelDefaultLimits.get(voltageLevel.getId()).getHighVoltageLimit() != null; final CounterToIncrement counterToIncrementLow = generateLowVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isLowVoltageLimitModificationSet, isLowVoltageLimitDefaultSet, voltageLevel, voltageLevelsIdsRestricted); + final VoltageLimitOverride lowOverride = counterToIncrementLow == CounterToIncrement.NONE ? null : specificVoltageLimits.peekLast(); final CounterToIncrement counterToIncrementHigh = generateHighVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isHighVoltageLimitModificationSet, isHighVoltageLimitDefaultSet, voltageLevel); - if (counterToIncrementLow == CounterToIncrement.DEFAULT || counterToIncrementLow == CounterToIncrement.BOTH || - counterToIncrementHigh == CounterToIncrement.DEFAULT || counterToIncrementHigh == CounterToIncrement.BOTH) { - counterMissingVoltageLimits.increment(); - } - if (counterToIncrementLow == CounterToIncrement.MODIFICATION || counterToIncrementLow == CounterToIncrement.BOTH || - counterToIncrementHigh == CounterToIncrement.MODIFICATION || counterToIncrementHigh == CounterToIncrement.BOTH) { - counterVoltageLimitModifications.increment(); + final CounterToIncrement counterToIncrement = counterToIncrementLow.merge(counterToIncrementHigh); + if (counterToIncrement != CounterToIncrement.NONE) { + logVoltageLimitModified(reporter, voltageLevel, lowOverride, counterToIncrementHigh == CounterToIncrement.NONE ? null : specificVoltageLimits.peekLast()); } + return counterToIncrement; } private static CounterToIncrement generateLowVoltageLimit(List specificVoltageLimits, @@ -198,7 +196,7 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, } OpenReacParameters parameters = new OpenReacParameters(); - List specificVoltageLimits = new ArrayList<>(); + LinkedList specificVoltageLimits = new LinkedList<>(); List constantQGenerators = new ArrayList<>(); List variableTwoWindingsTransformers = new ArrayList<>(); List variableShuntCompensators = new ArrayList<>(); @@ -217,10 +215,18 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, network.getVoltageLevelStream() .filter(voltageLevel -> voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) || voltageLevelModificationLimits.containsKey(voltageLevel.getId())) - .forEach(voltageLevel -> fillSpecificVoltageLimits(specificVoltageLimits, - counterMissingVoltageLimits, counterVoltageLimitModifications, - voltageLevelModificationLimits, voltageLevelDefaultLimits, - voltageLevel, context.getVoltageLevelsIdsRestricted())); + .forEach(voltageLevel -> { + final CounterToIncrement counterToIncrement = fillSpecificVoltageLimits(reporter, + specificVoltageLimits, + voltageLevelModificationLimits, voltageLevelDefaultLimits, + voltageLevel, context.getVoltageLevelsIdsRestricted()); + if (counterToIncrement == CounterToIncrement.DEFAULT || counterToIncrement == CounterToIncrement.BOTH) { + counterMissingVoltageLimits.increment(); + } + if (counterToIncrement == CounterToIncrement.MODIFICATION || counterToIncrement == CounterToIncrement.BOTH) { + counterVoltageLimitModifications.increment(); + } + }); logRestrictedVoltageLevels(reporter, context.getVoltageLevelsIdsRestricted()); } @@ -234,7 +240,6 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, .addVariableTwoWindingsTransformers(variableTwoWindingsTransformers) .addVariableShuntCompensators(variableShuntCompensators); - logVoltageLimitsModified(reporter, network, parameters.getSpecificVoltageLimits()); logFiltersCounters(reporter, counterMissingVoltageLimits, counterVoltageLimitModifications); //The optimizer will attach reactive slack variables to all buses @@ -288,31 +293,16 @@ private static void logFiltersCounters(final Reporter reporter, final MutableInt .build()); } - private static void logVoltageLimitsModified(final Reporter reporter, final Network network, final List specificVoltageLimits) { - specificVoltageLimits - .stream() - .collect(HashMap>::new, - (map, voltageLimitOverride) -> map - .computeIfAbsent(voltageLimitOverride.getVoltageLevelId(), key -> new EnumMap<>(VoltageLimitType.class)) - .put(voltageLimitOverride.getVoltageLimitType(), voltageLimitOverride), - (map, map2) -> map2.forEach((id, newLimits) -> map.merge(id, newLimits, (newLimit1, newLimit2) -> { - newLimit1.putAll(newLimit2); - return newLimit1; - }) - )) - .forEach((id, voltageLimits) -> { - final VoltageLevel voltageLevel = network.getVoltageLevel(id); - final double initialLowVoltageLimit = voltageLevel.getLowVoltageLimit(); - final double initialHighVoltage = voltageLevel.getHighVoltageLimit(); - reporter.report(Report.builder() - .withKey("voltageLimitModified") - .withDefaultMessage("Voltage limits of ${voltageLevelId} modified: low voltage limit = ${lowVoltageLimit}, high voltage limit = ${highVoltageLimit}") - .withTypedValue("voltageLevelId", voltageLevel.getId(), TypedValue.VOLTAGE_LEVEL) - .withTypedValue("lowVoltageLimit", computeRelativeVoltageLevel(initialLowVoltageLimit, voltageLimits.get(VoltageLimitType.LOW_VOLTAGE_LIMIT)), TypedValue.VOLTAGE) - .withTypedValue("highVoltageLimit", computeRelativeVoltageLevel(initialHighVoltage, voltageLimits.get(VoltageLimitType.HIGH_VOLTAGE_LIMIT)), TypedValue.VOLTAGE) - .withSeverity(TypedValue.TRACE_SEVERITY) - .build()); - }); + private static void logVoltageLimitModified(final Reporter reporter, final VoltageLevel voltageLevel, + final VoltageLimitOverride lowOverride, final VoltageLimitOverride highOverride) { + reporter.report(Report.builder() + .withKey("voltageLimitModified") + .withDefaultMessage("Voltage limits of ${voltageLevelId} modified: low voltage limit = ${lowVoltageLimit}, high voltage limit = ${highVoltageLimit}") + .withTypedValue("voltageLevelId", voltageLevel.getId(), TypedValue.VOLTAGE_LEVEL) + .withTypedValue("lowVoltageLimit", computeRelativeVoltageLevel(voltageLevel.getLowVoltageLimit(), lowOverride), TypedValue.VOLTAGE) + .withTypedValue("highVoltageLimit", computeRelativeVoltageLevel(voltageLevel.getHighVoltageLimit(), highOverride), TypedValue.VOLTAGE) + .withSeverity(TypedValue.TRACE_SEVERITY) + .build()); } private static String voltageToString(double voltage) { @@ -332,6 +322,16 @@ private static String computeRelativeVoltageLevel(final double initialVoltageLim */ @VisibleForTesting enum CounterToIncrement { - NONE, DEFAULT, MODIFICATION, BOTH + NONE, DEFAULT, MODIFICATION, BOTH; + + public CounterToIncrement merge(@NonNull final CounterToIncrement other) { + if (this == BOTH || other == BOTH || this == DEFAULT && other == MODIFICATION || this == MODIFICATION && other == DEFAULT) { + return BOTH; + } else if (this == NONE) { + return other; + } else { // other == NONE + return this; + } + } } } diff --git a/src/test/java/org/gridsuite/voltageinit/server/service/parameters/ParametersTest.java b/src/test/java/org/gridsuite/voltageinit/server/service/parameters/ParametersTest.java index 0f79a81e..ff63ae93 100644 --- a/src/test/java/org/gridsuite/voltageinit/server/service/parameters/ParametersTest.java +++ b/src/test/java/org/gridsuite/voltageinit/server/service/parameters/ParametersTest.java @@ -19,8 +19,10 @@ import com.powsybl.openreac.parameters.input.VoltageLimitOverride; import com.powsybl.openreac.parameters.input.VoltageLimitOverride.VoltageLimitType; import lombok.extern.slf4j.Slf4j; +import org.apache.commons.lang3.tuple.Triple; import org.assertj.core.api.Condition; import org.assertj.core.api.ListAssert; +import org.assertj.core.api.SoftAssertions; import org.assertj.core.api.junit.jupiter.SoftAssertionsExtension; import org.gridsuite.voltageinit.server.dto.parameters.FilterEquipments; import org.gridsuite.voltageinit.server.dto.parameters.IdentifiableAttributes; @@ -28,6 +30,7 @@ import org.gridsuite.voltageinit.server.entities.parameters.VoltageInitParametersEntity; import org.gridsuite.voltageinit.server.entities.parameters.VoltageLimitEntity; import org.gridsuite.voltageinit.server.service.VoltageInitRunContext; +import org.gridsuite.voltageinit.server.service.parameters.VoltageInitParametersService.CounterToIncrement; import org.gridsuite.voltageinit.server.util.VoltageLimitParameterType; import org.gridsuite.voltageinit.utils.TestUtils; import org.junit.jupiter.api.BeforeEach; @@ -77,7 +80,7 @@ class ParametersTest { private static final String FILTER_2 = "FILTER_2"; private static final UUID REPORT_UUID = UUID.fromString("00000000-0000-0000-0000-000000000000"); - private static final JSONComparator REPORTER_COMPARATOR = new CustomComparator(JSONCompareMode.STRICT, + private static final JSONComparator REPORTER_COMPARATOR = new CustomComparator(JSONCompareMode.NON_EXTENSIBLE, // ignore field having uuid changing each run new Customization("reportTree.subReporters[*].taskValues.parameters_id.value", (o1, o2) -> (o1 == null) == (o2 == null)) ); @@ -268,4 +271,30 @@ void testsBuildSpecificVoltageLimitsWithFourSubstationStudy() throws Exception { } JSONAssert.assertEquals("build parameters logs", TestUtils.resourceToString("reporter_fourSubstations_noVoltageLimits.json"), mapper.writeValueAsString(context.getRootReporter()), REPORTER_COMPARATOR); } + + @DisplayName("CounterToIncrement.merge()") + @Test + void testCounterToIncrementMerge(final SoftAssertions softly) { + List.of( + Triple.ofNonNull(CounterToIncrement.NONE, CounterToIncrement.NONE, CounterToIncrement.NONE), + Triple.ofNonNull(CounterToIncrement.NONE, CounterToIncrement.DEFAULT, CounterToIncrement.DEFAULT), + Triple.ofNonNull(CounterToIncrement.NONE, CounterToIncrement.MODIFICATION, CounterToIncrement.MODIFICATION), + Triple.ofNonNull(CounterToIncrement.NONE, CounterToIncrement.BOTH, CounterToIncrement.BOTH), + + Triple.ofNonNull(CounterToIncrement.DEFAULT, CounterToIncrement.NONE, CounterToIncrement.DEFAULT), + Triple.ofNonNull(CounterToIncrement.DEFAULT, CounterToIncrement.DEFAULT, CounterToIncrement.DEFAULT), + Triple.ofNonNull(CounterToIncrement.DEFAULT, CounterToIncrement.MODIFICATION, CounterToIncrement.BOTH), + Triple.ofNonNull(CounterToIncrement.DEFAULT, CounterToIncrement.BOTH, CounterToIncrement.BOTH), + + Triple.ofNonNull(CounterToIncrement.MODIFICATION, CounterToIncrement.NONE, CounterToIncrement.MODIFICATION), + Triple.ofNonNull(CounterToIncrement.MODIFICATION, CounterToIncrement.DEFAULT, CounterToIncrement.BOTH), + Triple.ofNonNull(CounterToIncrement.MODIFICATION, CounterToIncrement.MODIFICATION, CounterToIncrement.MODIFICATION), + Triple.ofNonNull(CounterToIncrement.MODIFICATION, CounterToIncrement.BOTH, CounterToIncrement.BOTH), + + Triple.ofNonNull(CounterToIncrement.BOTH, CounterToIncrement.NONE, CounterToIncrement.BOTH), + Triple.ofNonNull(CounterToIncrement.BOTH, CounterToIncrement.DEFAULT, CounterToIncrement.BOTH), + Triple.ofNonNull(CounterToIncrement.BOTH, CounterToIncrement.MODIFICATION, CounterToIncrement.BOTH), + Triple.ofNonNull(CounterToIncrement.BOTH, CounterToIncrement.BOTH, CounterToIncrement.BOTH) + ).forEach(tpl -> softly.assertThat(tpl.getLeft().merge(tpl.getMiddle())).as(tpl.getLeft() + " + " + tpl.getMiddle()).isSameAs(tpl.getRight())); + } } From 50266a162c7092b087c54bc7d4fe97c3e3499e72 Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Wed, 10 Apr 2024 12:17:12 +0200 Subject: [PATCH 46/53] fix message value format --- .../parameters/VoltageInitParametersService.java | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index 9b5f1872..f7f76546 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -7,6 +7,7 @@ package org.gridsuite.voltageinit.server.service.parameters; import java.text.DecimalFormat; +import java.text.DecimalFormatSymbols; import java.util.*; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicReference; @@ -23,6 +24,7 @@ import com.powsybl.openreac.parameters.input.VoltageLimitOverride.VoltageLimitType; import com.powsybl.openreac.parameters.input.algo.ReactiveSlackBusesMode; import lombok.NonNull; +import org.apache.commons.lang3.ObjectUtils; import org.apache.commons.lang3.mutable.MutableInt; import org.gridsuite.voltageinit.server.dto.parameters.FilterEquipments; import org.gridsuite.voltageinit.server.dto.parameters.IdentifiableAttributes; @@ -47,7 +49,7 @@ public class VoltageInitParametersService { private static final Logger LOGGER = LoggerFactory.getLogger(VoltageInitParametersService.class); - private static final DecimalFormat DF = new DecimalFormat("0.0"); + private static final DecimalFormat DF = new DecimalFormat("0.0\u202FkV", DecimalFormatSymbols.getInstance(Locale.ROOT)); private final FilterService filterService; @@ -271,7 +273,7 @@ private static void logRestrictedVoltageLevels(final Reporter reporter, final Ma .withValue("joinedVoltageLevelsIds", voltageLevelsIdsRestricted .entrySet() .stream() - .map(entry -> entry.getKey() + " : " + voltageToString(entry.getValue())) + .map(entry -> entry.getKey() + " : " + DF.format(ObjectUtils.defaultIfNull(entry.getValue(), Double.NaN))) .collect(Collectors.joining(", "))) .withSeverity(TypedValue.WARN_SEVERITY) .build()); @@ -305,15 +307,12 @@ private static void logVoltageLimitModified(final Reporter reporter, final Volta .build()); } - private static String voltageToString(double voltage) { - return Double.isNaN(voltage) ? DF.format(voltage) : voltage + "\u202FkV"; - } - private static String computeRelativeVoltageLevel(final double initialVoltageLimit, @Nullable final VoltageLimitOverride override) { if (override == null) { - return voltageToString(initialVoltageLimit); + return DF.format(initialVoltageLimit); } else { - return voltageToString(initialVoltageLimit) + " → " + voltageToString((override.isRelative() ? initialVoltageLimit : 0.0) + override.getLimit()); + double voltage = (override.isRelative() ? initialVoltageLimit : 0.0) + override.getLimit(); + return DF.format(initialVoltageLimit) + " → " + DF.format(voltage); } } From 4fe8d79f188ec5a0062dee4ca2fb61447be37762 Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Wed, 10 Apr 2024 14:02:52 +0200 Subject: [PATCH 47/53] Revert "optimize memory usage" This reverts commit 5e6bddad4c79e24e14aae4f12be27edfdbd3c507. --- .../VoltageInitParametersService.java | 91 ++++++++++--------- .../service/parameters/ParametersTest.java | 29 ------ 2 files changed, 46 insertions(+), 74 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index f7f76546..acbbf528 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -104,25 +104,28 @@ private Map resolveVoltageLevelLimits(VoltageInitRun return voltageLevelLimits; } - private static CounterToIncrement fillSpecificVoltageLimits(final Reporter reporter, - LinkedList specificVoltageLimits, - Map voltageLevelModificationLimits, - Map voltageLevelDefaultLimits, - VoltageLevel voltageLevel, - Map voltageLevelsIdsRestricted) { + private static void fillSpecificVoltageLimits(List specificVoltageLimits, + final MutableInt counterMissingVoltageLimits, + final MutableInt counterVoltageLimitModifications, + Map voltageLevelModificationLimits, + Map voltageLevelDefaultLimits, + VoltageLevel voltageLevel, + Map voltageLevelsIdsRestricted) { boolean isLowVoltageLimitModificationSet = voltageLevelModificationLimits.containsKey(voltageLevel.getId()) && voltageLevelModificationLimits.get(voltageLevel.getId()).getLowVoltageLimit() != null; boolean isHighVoltageLimitModificationSet = voltageLevelModificationLimits.containsKey(voltageLevel.getId()) && voltageLevelModificationLimits.get(voltageLevel.getId()).getHighVoltageLimit() != null; boolean isLowVoltageLimitDefaultSet = voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) && voltageLevelDefaultLimits.get(voltageLevel.getId()).getLowVoltageLimit() != null; boolean isHighVoltageLimitDefaultSet = voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) && voltageLevelDefaultLimits.get(voltageLevel.getId()).getHighVoltageLimit() != null; final CounterToIncrement counterToIncrementLow = generateLowVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isLowVoltageLimitModificationSet, isLowVoltageLimitDefaultSet, voltageLevel, voltageLevelsIdsRestricted); - final VoltageLimitOverride lowOverride = counterToIncrementLow == CounterToIncrement.NONE ? null : specificVoltageLimits.peekLast(); final CounterToIncrement counterToIncrementHigh = generateHighVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isHighVoltageLimitModificationSet, isHighVoltageLimitDefaultSet, voltageLevel); - final CounterToIncrement counterToIncrement = counterToIncrementLow.merge(counterToIncrementHigh); - if (counterToIncrement != CounterToIncrement.NONE) { - logVoltageLimitModified(reporter, voltageLevel, lowOverride, counterToIncrementHigh == CounterToIncrement.NONE ? null : specificVoltageLimits.peekLast()); + if (counterToIncrementLow == CounterToIncrement.DEFAULT || counterToIncrementLow == CounterToIncrement.BOTH || + counterToIncrementHigh == CounterToIncrement.DEFAULT || counterToIncrementHigh == CounterToIncrement.BOTH) { + counterMissingVoltageLimits.increment(); + } + if (counterToIncrementLow == CounterToIncrement.MODIFICATION || counterToIncrementLow == CounterToIncrement.BOTH || + counterToIncrementHigh == CounterToIncrement.MODIFICATION || counterToIncrementHigh == CounterToIncrement.BOTH) { + counterVoltageLimitModifications.increment(); } - return counterToIncrement; } private static CounterToIncrement generateLowVoltageLimit(List specificVoltageLimits, @@ -198,7 +201,7 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, } OpenReacParameters parameters = new OpenReacParameters(); - LinkedList specificVoltageLimits = new LinkedList<>(); + List specificVoltageLimits = new ArrayList<>(); List constantQGenerators = new ArrayList<>(); List variableTwoWindingsTransformers = new ArrayList<>(); List variableShuntCompensators = new ArrayList<>(); @@ -217,18 +220,10 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, network.getVoltageLevelStream() .filter(voltageLevel -> voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) || voltageLevelModificationLimits.containsKey(voltageLevel.getId())) - .forEach(voltageLevel -> { - final CounterToIncrement counterToIncrement = fillSpecificVoltageLimits(reporter, - specificVoltageLimits, - voltageLevelModificationLimits, voltageLevelDefaultLimits, - voltageLevel, context.getVoltageLevelsIdsRestricted()); - if (counterToIncrement == CounterToIncrement.DEFAULT || counterToIncrement == CounterToIncrement.BOTH) { - counterMissingVoltageLimits.increment(); - } - if (counterToIncrement == CounterToIncrement.MODIFICATION || counterToIncrement == CounterToIncrement.BOTH) { - counterVoltageLimitModifications.increment(); - } - }); + .forEach(voltageLevel -> fillSpecificVoltageLimits(specificVoltageLimits, + counterMissingVoltageLimits, counterVoltageLimitModifications, + voltageLevelModificationLimits, voltageLevelDefaultLimits, + voltageLevel, context.getVoltageLevelsIdsRestricted())); logRestrictedVoltageLevels(reporter, context.getVoltageLevelsIdsRestricted()); } @@ -242,6 +237,7 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, .addVariableTwoWindingsTransformers(variableTwoWindingsTransformers) .addVariableShuntCompensators(variableShuntCompensators); + logVoltageLimitsModified(reporter, network, parameters.getSpecificVoltageLimits()); logFiltersCounters(reporter, counterMissingVoltageLimits, counterVoltageLimitModifications); //The optimizer will attach reactive slack variables to all buses @@ -295,16 +291,31 @@ private static void logFiltersCounters(final Reporter reporter, final MutableInt .build()); } - private static void logVoltageLimitModified(final Reporter reporter, final VoltageLevel voltageLevel, - final VoltageLimitOverride lowOverride, final VoltageLimitOverride highOverride) { - reporter.report(Report.builder() - .withKey("voltageLimitModified") - .withDefaultMessage("Voltage limits of ${voltageLevelId} modified: low voltage limit = ${lowVoltageLimit}, high voltage limit = ${highVoltageLimit}") - .withTypedValue("voltageLevelId", voltageLevel.getId(), TypedValue.VOLTAGE_LEVEL) - .withTypedValue("lowVoltageLimit", computeRelativeVoltageLevel(voltageLevel.getLowVoltageLimit(), lowOverride), TypedValue.VOLTAGE) - .withTypedValue("highVoltageLimit", computeRelativeVoltageLevel(voltageLevel.getHighVoltageLimit(), highOverride), TypedValue.VOLTAGE) - .withSeverity(TypedValue.TRACE_SEVERITY) - .build()); + private static void logVoltageLimitsModified(final Reporter reporter, final Network network, final List specificVoltageLimits) { + specificVoltageLimits + .stream() + .collect(HashMap>::new, + (map, voltageLimitOverride) -> map + .computeIfAbsent(voltageLimitOverride.getVoltageLevelId(), key -> new EnumMap<>(VoltageLimitType.class)) + .put(voltageLimitOverride.getVoltageLimitType(), voltageLimitOverride), + (map, map2) -> map2.forEach((id, newLimits) -> map.merge(id, newLimits, (newLimit1, newLimit2) -> { + newLimit1.putAll(newLimit2); + return newLimit1; + }) + )) + .forEach((id, voltageLimits) -> { + final VoltageLevel voltageLevel = network.getVoltageLevel(id); + final double initialLowVoltageLimit = voltageLevel.getLowVoltageLimit(); + final double initialHighVoltage = voltageLevel.getHighVoltageLimit(); + reporter.report(Report.builder() + .withKey("voltageLimitModified") + .withDefaultMessage("Voltage limits of ${voltageLevelId} modified: low voltage limit = ${lowVoltageLimit}, high voltage limit = ${highVoltageLimit}") + .withTypedValue("voltageLevelId", voltageLevel.getId(), TypedValue.VOLTAGE_LEVEL) + .withTypedValue("lowVoltageLimit", computeRelativeVoltageLevel(initialLowVoltageLimit, voltageLimits.get(VoltageLimitType.LOW_VOLTAGE_LIMIT)), TypedValue.VOLTAGE) + .withTypedValue("highVoltageLimit", computeRelativeVoltageLevel(initialHighVoltage, voltageLimits.get(VoltageLimitType.HIGH_VOLTAGE_LIMIT)), TypedValue.VOLTAGE) + .withSeverity(TypedValue.TRACE_SEVERITY) + .build()); + }); } private static String computeRelativeVoltageLevel(final double initialVoltageLimit, @Nullable final VoltageLimitOverride override) { @@ -321,16 +332,6 @@ private static String computeRelativeVoltageLevel(final double initialVoltageLim */ @VisibleForTesting enum CounterToIncrement { - NONE, DEFAULT, MODIFICATION, BOTH; - - public CounterToIncrement merge(@NonNull final CounterToIncrement other) { - if (this == BOTH || other == BOTH || this == DEFAULT && other == MODIFICATION || this == MODIFICATION && other == DEFAULT) { - return BOTH; - } else if (this == NONE) { - return other; - } else { // other == NONE - return this; - } - } + NONE, DEFAULT, MODIFICATION, BOTH } } diff --git a/src/test/java/org/gridsuite/voltageinit/server/service/parameters/ParametersTest.java b/src/test/java/org/gridsuite/voltageinit/server/service/parameters/ParametersTest.java index ff63ae93..5cbb9b87 100644 --- a/src/test/java/org/gridsuite/voltageinit/server/service/parameters/ParametersTest.java +++ b/src/test/java/org/gridsuite/voltageinit/server/service/parameters/ParametersTest.java @@ -19,10 +19,8 @@ import com.powsybl.openreac.parameters.input.VoltageLimitOverride; import com.powsybl.openreac.parameters.input.VoltageLimitOverride.VoltageLimitType; import lombok.extern.slf4j.Slf4j; -import org.apache.commons.lang3.tuple.Triple; import org.assertj.core.api.Condition; import org.assertj.core.api.ListAssert; -import org.assertj.core.api.SoftAssertions; import org.assertj.core.api.junit.jupiter.SoftAssertionsExtension; import org.gridsuite.voltageinit.server.dto.parameters.FilterEquipments; import org.gridsuite.voltageinit.server.dto.parameters.IdentifiableAttributes; @@ -30,7 +28,6 @@ import org.gridsuite.voltageinit.server.entities.parameters.VoltageInitParametersEntity; import org.gridsuite.voltageinit.server.entities.parameters.VoltageLimitEntity; import org.gridsuite.voltageinit.server.service.VoltageInitRunContext; -import org.gridsuite.voltageinit.server.service.parameters.VoltageInitParametersService.CounterToIncrement; import org.gridsuite.voltageinit.server.util.VoltageLimitParameterType; import org.gridsuite.voltageinit.utils.TestUtils; import org.junit.jupiter.api.BeforeEach; @@ -271,30 +268,4 @@ void testsBuildSpecificVoltageLimitsWithFourSubstationStudy() throws Exception { } JSONAssert.assertEquals("build parameters logs", TestUtils.resourceToString("reporter_fourSubstations_noVoltageLimits.json"), mapper.writeValueAsString(context.getRootReporter()), REPORTER_COMPARATOR); } - - @DisplayName("CounterToIncrement.merge()") - @Test - void testCounterToIncrementMerge(final SoftAssertions softly) { - List.of( - Triple.ofNonNull(CounterToIncrement.NONE, CounterToIncrement.NONE, CounterToIncrement.NONE), - Triple.ofNonNull(CounterToIncrement.NONE, CounterToIncrement.DEFAULT, CounterToIncrement.DEFAULT), - Triple.ofNonNull(CounterToIncrement.NONE, CounterToIncrement.MODIFICATION, CounterToIncrement.MODIFICATION), - Triple.ofNonNull(CounterToIncrement.NONE, CounterToIncrement.BOTH, CounterToIncrement.BOTH), - - Triple.ofNonNull(CounterToIncrement.DEFAULT, CounterToIncrement.NONE, CounterToIncrement.DEFAULT), - Triple.ofNonNull(CounterToIncrement.DEFAULT, CounterToIncrement.DEFAULT, CounterToIncrement.DEFAULT), - Triple.ofNonNull(CounterToIncrement.DEFAULT, CounterToIncrement.MODIFICATION, CounterToIncrement.BOTH), - Triple.ofNonNull(CounterToIncrement.DEFAULT, CounterToIncrement.BOTH, CounterToIncrement.BOTH), - - Triple.ofNonNull(CounterToIncrement.MODIFICATION, CounterToIncrement.NONE, CounterToIncrement.MODIFICATION), - Triple.ofNonNull(CounterToIncrement.MODIFICATION, CounterToIncrement.DEFAULT, CounterToIncrement.BOTH), - Triple.ofNonNull(CounterToIncrement.MODIFICATION, CounterToIncrement.MODIFICATION, CounterToIncrement.MODIFICATION), - Triple.ofNonNull(CounterToIncrement.MODIFICATION, CounterToIncrement.BOTH, CounterToIncrement.BOTH), - - Triple.ofNonNull(CounterToIncrement.BOTH, CounterToIncrement.NONE, CounterToIncrement.BOTH), - Triple.ofNonNull(CounterToIncrement.BOTH, CounterToIncrement.DEFAULT, CounterToIncrement.BOTH), - Triple.ofNonNull(CounterToIncrement.BOTH, CounterToIncrement.MODIFICATION, CounterToIncrement.BOTH), - Triple.ofNonNull(CounterToIncrement.BOTH, CounterToIncrement.BOTH, CounterToIncrement.BOTH) - ).forEach(tpl -> softly.assertThat(tpl.getLeft().merge(tpl.getMiddle())).as(tpl.getLeft() + " + " + tpl.getMiddle()).isSameAs(tpl.getRight())); - } } From f61e7a77b879290734204f3db24dffd57a1c6e94 Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Wed, 10 Apr 2024 14:06:26 +0200 Subject: [PATCH 48/53] checkstyle --- .../server/service/parameters/VoltageInitParametersService.java | 1 - 1 file changed, 1 deletion(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index acbbf528..548b5a8c 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -23,7 +23,6 @@ import com.powsybl.openreac.parameters.input.VoltageLimitOverride; import com.powsybl.openreac.parameters.input.VoltageLimitOverride.VoltageLimitType; import com.powsybl.openreac.parameters.input.algo.ReactiveSlackBusesMode; -import lombok.NonNull; import org.apache.commons.lang3.ObjectUtils; import org.apache.commons.lang3.mutable.MutableInt; import org.gridsuite.voltageinit.server.dto.parameters.FilterEquipments; From 7d042e2bfd6fa97d84016c77f539b4b7a62cced7 Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Wed, 10 Apr 2024 14:09:32 +0200 Subject: [PATCH 49/53] review --- .../service/parameters/VoltageInitParametersService.java | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index 548b5a8c..92602870 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -237,7 +237,7 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, .addVariableShuntCompensators(variableShuntCompensators); logVoltageLimitsModified(reporter, network, parameters.getSpecificVoltageLimits()); - logFiltersCounters(reporter, counterMissingVoltageLimits, counterVoltageLimitModifications); + logVoltageLimitsModificationCounters(reporter, counterMissingVoltageLimits, counterVoltageLimitModifications); //The optimizer will attach reactive slack variables to all buses parameters.setReactiveSlackBusesMode(ReactiveSlackBusesMode.ALL); @@ -275,7 +275,9 @@ private static void logRestrictedVoltageLevels(final Reporter reporter, final Ma } } - private static void logFiltersCounters(final Reporter reporter, final MutableInt counterMissingVoltageLimits, final MutableInt counterVoltageLimitModifications) { + private static void logVoltageLimitsModificationCounters(final Reporter reporter, + final MutableInt counterMissingVoltageLimits, + final MutableInt counterVoltageLimitModifications) { reporter.report(Report.builder() .withKey("missingVoltageLimits") .withDefaultMessage("Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.") From 01020e9292abacb479c2b8ef22d9fcef0e1fdec2 Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Wed, 10 Apr 2024 14:18:37 +0200 Subject: [PATCH 50/53] rename constant --- .../service/parameters/VoltageInitParametersService.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index 92602870..2e8e3078 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -48,7 +48,7 @@ public class VoltageInitParametersService { private static final Logger LOGGER = LoggerFactory.getLogger(VoltageInitParametersService.class); - private static final DecimalFormat DF = new DecimalFormat("0.0\u202FkV", DecimalFormatSymbols.getInstance(Locale.ROOT)); + private static final DecimalFormat VOLTAGE_FORMAT = new DecimalFormat("0.0\u202FkV", DecimalFormatSymbols.getInstance(Locale.ROOT)); private final FilterService filterService; @@ -268,7 +268,7 @@ private static void logRestrictedVoltageLevels(final Reporter reporter, final Ma .withValue("joinedVoltageLevelsIds", voltageLevelsIdsRestricted .entrySet() .stream() - .map(entry -> entry.getKey() + " : " + DF.format(ObjectUtils.defaultIfNull(entry.getValue(), Double.NaN))) + .map(entry -> entry.getKey() + " : " + VOLTAGE_FORMAT.format(ObjectUtils.defaultIfNull(entry.getValue(), Double.NaN))) .collect(Collectors.joining(", "))) .withSeverity(TypedValue.WARN_SEVERITY) .build()); @@ -321,10 +321,10 @@ private static void logVoltageLimitsModified(final Reporter reporter, final Netw private static String computeRelativeVoltageLevel(final double initialVoltageLimit, @Nullable final VoltageLimitOverride override) { if (override == null) { - return DF.format(initialVoltageLimit); + return VOLTAGE_FORMAT.format(initialVoltageLimit); } else { double voltage = (override.isRelative() ? initialVoltageLimit : 0.0) + override.getLimit(); - return DF.format(initialVoltageLimit) + " → " + DF.format(voltage); + return VOLTAGE_FORMAT.format(initialVoltageLimit) + " → " + VOLTAGE_FORMAT.format(voltage); } } From 94000b5e5684fc846b28024f93ab3c76206cee60 Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Wed, 10 Apr 2024 14:37:20 +0200 Subject: [PATCH 51/53] review --- .../server/service/VoltageInitRunContext.java | 1 + .../VoltageInitParametersService.java | 22 ++++++++++--------- 2 files changed, 13 insertions(+), 10 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitRunContext.java b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitRunContext.java index 1bcb6d78..2c35a5ff 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitRunContext.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/VoltageInitRunContext.java @@ -40,6 +40,7 @@ public class VoltageInitRunContext { private final UUID parametersUuid; private final Map voltageLevelsIdsRestricted; + @Setter private Reporter rootReporter; public VoltageInitRunContext(UUID networkUuid, String variantId, String receiver, UUID reportUuid, String reporterId, String reportType, String userId, UUID parametersUuid, Map voltageLevelsIdsRestricted) { diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index 2e8e3078..0bcd18c4 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -104,8 +104,8 @@ private Map resolveVoltageLevelLimits(VoltageInitRun } private static void fillSpecificVoltageLimits(List specificVoltageLimits, - final MutableInt counterMissingVoltageLimits, - final MutableInt counterVoltageLimitModifications, + final MutableInt missingVoltageLimitsCounter, + final MutableInt voltageLimitModificationsCounter, Map voltageLevelModificationLimits, Map voltageLevelDefaultLimits, VoltageLevel voltageLevel, @@ -119,11 +119,11 @@ private static void fillSpecificVoltageLimits(List specifi final CounterToIncrement counterToIncrementHigh = generateHighVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isHighVoltageLimitModificationSet, isHighVoltageLimitDefaultSet, voltageLevel); if (counterToIncrementLow == CounterToIncrement.DEFAULT || counterToIncrementLow == CounterToIncrement.BOTH || counterToIncrementHigh == CounterToIncrement.DEFAULT || counterToIncrementHigh == CounterToIncrement.BOTH) { - counterMissingVoltageLimits.increment(); + missingVoltageLimitsCounter.increment(); } if (counterToIncrementLow == CounterToIncrement.MODIFICATION || counterToIncrementLow == CounterToIncrement.BOTH || counterToIncrementHigh == CounterToIncrement.MODIFICATION || counterToIncrementHigh == CounterToIncrement.BOTH) { - counterVoltageLimitModifications.increment(); + voltageLimitModificationsCounter.increment(); } } @@ -204,8 +204,8 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, List constantQGenerators = new ArrayList<>(); List variableTwoWindingsTransformers = new ArrayList<>(); List variableShuntCompensators = new ArrayList<>(); - final MutableInt counterMissingVoltageLimits = new MutableInt(0); - final MutableInt counterVoltageLimitModifications = new MutableInt(0); + final MutableInt missingVoltageLimitsCounter = new MutableInt(0); + final MutableInt voltageLimitModificationsCounter = new MutableInt(0); voltageInitParametersEntity.ifPresent(voltageInitParameters -> { if (voltageInitParameters.getVoltageLimits() != null) { @@ -220,7 +220,7 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, network.getVoltageLevelStream() .filter(voltageLevel -> voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) || voltageLevelModificationLimits.containsKey(voltageLevel.getId())) .forEach(voltageLevel -> fillSpecificVoltageLimits(specificVoltageLimits, - counterMissingVoltageLimits, counterVoltageLimitModifications, + missingVoltageLimitsCounter, voltageLimitModificationsCounter, voltageLevelModificationLimits, voltageLevelDefaultLimits, voltageLevel, context.getVoltageLevelsIdsRestricted())); @@ -236,8 +236,8 @@ public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, .addVariableTwoWindingsTransformers(variableTwoWindingsTransformers) .addVariableShuntCompensators(variableShuntCompensators); - logVoltageLimitsModified(reporter, network, parameters.getSpecificVoltageLimits()); - logVoltageLimitsModificationCounters(reporter, counterMissingVoltageLimits, counterVoltageLimitModifications); + logVoltageLimitsModifications(reporter, network, parameters.getSpecificVoltageLimits()); + logVoltageLimitsModificationCounters(reporter, missingVoltageLimitsCounter, voltageLimitModificationsCounter); //The optimizer will attach reactive slack variables to all buses parameters.setReactiveSlackBusesMode(ReactiveSlackBusesMode.ALL); @@ -292,7 +292,9 @@ private static void logVoltageLimitsModificationCounters(final Reporter reporter .build()); } - private static void logVoltageLimitsModified(final Reporter reporter, final Network network, final List specificVoltageLimits) { + private static void logVoltageLimitsModifications(final Reporter reporter, + final Network network, + final List specificVoltageLimits) { specificVoltageLimits .stream() .collect(HashMap>::new, From 62915935703025a437a49ad7e86e90157fb5cbe6 Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Wed, 10 Apr 2024 14:57:42 +0200 Subject: [PATCH 52/53] fix sanor --- .../service/parameters/VoltageInitParametersService.java | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index 0bcd18c4..afbdf062 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -158,12 +158,10 @@ private static CounterToIncrement generateLowVoltageLimit(List specificVoltageLimits, From c21ef211df72a5f5666755198a33f77088c03852 Mon Sep 17 00:00:00 2001 From: Tristan Chuine Date: Wed, 10 Apr 2024 16:24:42 +0200 Subject: [PATCH 53/53] review --- .../service/parameters/VoltageInitParametersService.java | 2 +- src/test/resources/reporter_buildOpenReacParameters.json | 4 ++-- .../reporter_buildOpenReacParameters_caseRelativeFalse.json | 4 ++-- .../reporter_buildOpenReacParameters_caseRelativeTrue.json | 4 ++-- ...porter_buildOpenReacParameters_withLimitModifications.json | 4 ++-- .../resources/reporter_fourSubstations_noVoltageLimits.json | 4 ++-- 6 files changed, 11 insertions(+), 11 deletions(-) diff --git a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java index afbdf062..3eb09143 100644 --- a/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java +++ b/src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java @@ -188,7 +188,7 @@ private static CounterToIncrement generateHighVoltageLimit(List startTime = new AtomicReference<>(System.nanoTime()); - final Reporter reporter = context.getRootReporter().createSubReporter("OpenReacParameters", "OpenReac parameters", Map.of( + final Reporter reporter = context.getRootReporter().createSubReporter("VoltageInitParameters", "VoltageInit parameters", Map.of( "parameters_id", new TypedValue(Objects.toString(context.getParametersUuid()), "ID") )); diff --git a/src/test/resources/reporter_buildOpenReacParameters.json b/src/test/resources/reporter_buildOpenReacParameters.json index 2d92903c..76bdeece 100644 --- a/src/test/resources/reporter_buildOpenReacParameters.json +++ b/src/test/resources/reporter_buildOpenReacParameters.json @@ -4,7 +4,7 @@ "taskKey": "VoltageInit", "subReporters": [ { - "taskKey": "OpenReacParameters", + "taskKey": "VoltageInitParameters", "taskValues": { "parameters_id": { "value": "11111111-1111-1111-1111-111111111111", @@ -106,7 +106,7 @@ "dics": { "default": { "voltageLimitModifications": "Voltage limits of ${nbVoltageLimitModifications} voltage levels have been modified according to user input.", - "OpenReacParameters": "OpenReac parameters", + "VoltageInitParameters": "VoltageInit parameters", "VoltageInit": "VoltageInit", "missingVoltageLimits": "Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.", "voltageLimitModified": "Voltage limits of ${voltageLevelId} modified: low voltage limit = ${lowVoltageLimit}, high voltage limit = ${highVoltageLimit}" diff --git a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json index 8eec2557..e6e7b3ef 100644 --- a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json +++ b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeFalse.json @@ -4,7 +4,7 @@ "taskKey": "VoltageInit", "subReporters": [ { - "taskKey": "OpenReacParameters", + "taskKey": "VoltageInitParameters", "taskValues": { "parameters_id": { "value": "11111111-1111-1111-1111-111111111111", @@ -140,7 +140,7 @@ "default": { "restrictedVoltageLevels": "The modifications to the low limits for certain voltage levels have been restricted to avoid negative voltage limits: ${joinedVoltageLevelsIds}", "voltageLimitModifications": "Voltage limits of ${nbVoltageLimitModifications} voltage levels have been modified according to user input.", - "OpenReacParameters": "OpenReac parameters", + "VoltageInitParameters": "VoltageInit parameters", "VoltageInit": "VoltageInit", "missingVoltageLimits": "Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.", "voltageLimitModified": "Voltage limits of ${voltageLevelId} modified: low voltage limit = ${lowVoltageLimit}, high voltage limit = ${highVoltageLimit}" diff --git a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json index abc131c3..11e4c78b 100644 --- a/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json +++ b/src/test/resources/reporter_buildOpenReacParameters_caseRelativeTrue.json @@ -4,7 +4,7 @@ "taskKey": "VoltageInit", "subReporters": [ { - "taskKey": "OpenReacParameters", + "taskKey": "VoltageInitParameters", "taskValues": { "parameters_id": { "value": "11111111-1111-1111-1111-111111111111", @@ -119,7 +119,7 @@ "default": { "restrictedVoltageLevels": "The modifications to the low limits for certain voltage levels have been restricted to avoid negative voltage limits: ${joinedVoltageLevelsIds}", "voltageLimitModifications": "Voltage limits of ${nbVoltageLimitModifications} voltage levels have been modified according to user input.", - "OpenReacParameters": "OpenReac parameters", + "VoltageInitParameters": "VoltageInit parameters", "VoltageInit": "VoltageInit", "missingVoltageLimits": "Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.", "voltageLimitModified": "Voltage limits of ${voltageLevelId} modified: low voltage limit = ${lowVoltageLimit}, high voltage limit = ${highVoltageLimit}" diff --git a/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json b/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json index 1bdde9cf..b849d44b 100644 --- a/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json +++ b/src/test/resources/reporter_buildOpenReacParameters_withLimitModifications.json @@ -4,7 +4,7 @@ "taskKey": "VoltageInit", "subReporters": [ { - "taskKey": "OpenReacParameters", + "taskKey": "VoltageInitParameters", "taskValues": { "parameters_id": { "value": "11111111-1111-1111-1111-111111111111", @@ -127,7 +127,7 @@ "dics": { "default": { "voltageLimitModifications": "Voltage limits of ${nbVoltageLimitModifications} voltage levels have been modified according to user input.", - "OpenReacParameters": "OpenReac parameters", + "VoltageInitParameters": "VoltageInit parameters", "VoltageInit": "VoltageInit", "missingVoltageLimits": "Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.", "voltageLimitModified": "Voltage limits of ${voltageLevelId} modified: low voltage limit = ${lowVoltageLimit}, high voltage limit = ${highVoltageLimit}" diff --git a/src/test/resources/reporter_fourSubstations_noVoltageLimits.json b/src/test/resources/reporter_fourSubstations_noVoltageLimits.json index 4c4cb544..19c7c680 100644 --- a/src/test/resources/reporter_fourSubstations_noVoltageLimits.json +++ b/src/test/resources/reporter_fourSubstations_noVoltageLimits.json @@ -4,7 +4,7 @@ "taskKey": "VoltageInit", "subReporters": [ { - "taskKey": "OpenReacParameters", + "taskKey": "VoltageInitParameters", "taskValues": { "parameters_id": { "value": "11111111-1111-1111-11111111111111111", @@ -106,7 +106,7 @@ "dics": { "default": { "voltageLimitModifications": "Voltage limits of ${nbVoltageLimitModifications} voltage levels have been modified according to user input.", - "OpenReacParameters": "OpenReac parameters", + "VoltageInitParameters": "VoltageInit parameters", "VoltageInit": "VoltageInit", "missingVoltageLimits": "Missing voltage limits of ${nbMissingVoltageLimits} voltage levels have been replaced with user-defined default values.", "voltageLimitModified": "Voltage limits of ${voltageLevelId} modified: low voltage limit = ${lowVoltageLimit}, high voltage limit = ${highVoltageLimit}"