uuidSupplier = UUID::randomUUID;
+
+ public static UUID generateUUID() {
+ return uuidSupplier.get();
+ }
+
+ /**
+ * Like {@link UUID#randomUUID()} generate UUID v4 variant 2, but not random.
+ * This utility function is intended to be used in tests to have predictable UUID.
+ * Some information on UUID:
+ *
+ * textual format: xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx
+ * bytes: 0 1 2 3 4 5 6 7 8 9 10 ↓12 ↓14 ↓
+ * 11 13 15
+ * size: 4b-2b-2b-2b-6b
+ *
+ * Where
+ * - M = version field (4 bits).
+ * - N = variant field (3 bits).
+ * - All other bits = random (for v4).
+ *
+ * UUID bytes structure:
+ *
+ * /-------mostSigBits-------\ /--------leastSigBits---------\
+ * b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 b10 b11 b12 b13 b14 b15
+ * |-----------| |-----| |-----| |-----| |-----------------------|
+ * random random v4+random variant+random random
+ * b6 = [0100 LLLL] ⇒ version 4
+ * b8 = [10xL LLLL] → [1000 LLLL] ⇒ RFC 4122 / IETF / Leach–Salz variant
+ *
+ *
+ * @param b0to3 the bits from b0 to b3
+ * @param b4to5 the bits from b4 and b5
+ * @param b7 the bits of b7
+ * @param nibblesB6lowB8low the upper nibble is for the lower half of b6
+ * and the lower nibble is for the lower half of b8
+ * @param b9 the bits of b9
+ * @param b10to11 the bits for b10 and b11
+ * @param b12to15 the bits for b12 to b15
+ * @return a UUID v4 in variant 2 with the bits passed
+ * @implNote Bits 5–4 of b8 are left to {@code 0} for simplicity,
+ * so the UUID is of the form {@code xxxxxxxx-xxxx-4xxx-8xxx-xxxxxxxxxxxx}.
+ */
+ // regexp: ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-8[0-9a-f]{3}-[0-9a-f]{12}$
+ @VisibleForTesting
+ public static UUID createUUID(final int b0to3, final short b4to5, final byte b7,
+ final byte nibblesB6lowB8low,
+ final byte b9, final short b10to11, final int b12to15) {
+ return new UUID(
+ // Construct mostSigBits directly
+ (b0to3 & 0xFFFFFFFFL) << 32
+ | (b4to5 & 0xFFFFL) << 16
+ | (0x40L | ((nibblesB6lowB8low >>> 4) & 0x0FL)) << 8 // version 4
+ | (b7 & 0xFFL),
+ // Construct leastSigBits directly
+ (0x80L | (nibblesB6lowB8low & 0xFL)) << 56 // variant 2
+ | (b9 & 0xFFL) << 48
+ | (b10to11 & 0xFFFFL) << 32
+ | (b12to15 & 0xFFFFFFFFL)
+ );
+ }
+
+ /**
+ * @see #createUUID(int, short, byte, byte, byte, short, int)
+ */
+ @VisibleForTesting
+ public static UUID createUUID(final int b12to15) {
+ return createUUID(0, (short) 0, (byte) 0, (byte) 0, (byte) 0, (short) 0, b12to15);
+ }
+}
diff --git a/src/main/java/org/gridsuite/filter/utils/expertfilter/ExpertFilterUtils.java b/src/main/java/org/gridsuite/filter/utils/expertfilter/ExpertFilterUtils.java
index c9a22ec..db70edd 100644
--- a/src/main/java/org/gridsuite/filter/utils/expertfilter/ExpertFilterUtils.java
+++ b/src/main/java/org/gridsuite/filter/utils/expertfilter/ExpertFilterUtils.java
@@ -13,10 +13,13 @@
import com.powsybl.iidm.network.extensions.StandbyAutomaton;
import org.apache.commons.collections4.CollectionUtils;
import org.gridsuite.filter.FilterLoader;
+import org.gridsuite.filter.expertfilter.ExpertFilter;
+import org.gridsuite.filter.expertfilter.expertrule.AbstractExpertRule;
+import org.gridsuite.filter.expertfilter.expertrule.CombinatorExpertRule;
+import org.gridsuite.filter.expertfilter.expertrule.FilterUuidExpertRule;
import org.gridsuite.filter.identifierlistfilter.FilterEquipments;
import org.gridsuite.filter.identifierlistfilter.IdentifiableAttributes;
-import org.gridsuite.filter.utils.FilterServiceUtils;
-import org.gridsuite.filter.utils.RegulationType;
+import org.gridsuite.filter.utils.*;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
@@ -614,7 +617,7 @@ public static List getFilterEquipments(Network network, Set FilterCycleDetector.checkNoCycle(filter, filterLoader));
List filterEquipments = FilterServiceUtils.getFilterEquipmentsFromUuid(network, uuid, filterLoader);
- cachedUuidFilters.put(uuid, !CollectionUtils.isEmpty(filterEquipments) ? filterEquipments.getFirst() : null);
+ cachedUuidFilters.put(uuid, CollectionUtils.isNotEmpty(filterEquipments) ? filterEquipments.getFirst() : null);
res.addAll(filterEquipments);
}
});
@@ -626,4 +629,31 @@ public static boolean isPartOf(Network network, String value, Set uuids,
return equipments.stream().flatMap(e -> e.getIdentifiableAttributes().stream()
.map(IdentifiableAttributes::getId)).collect(Collectors.toSet()).contains(value);
}
+
+ /**
+ * Build an "OR" rule from the rules passed.
+ * @param rules the rule(s) to be applied
+ * @return {@link Optional#empty() Empty} if no rule is passed,
+ * the {@link AbstractExpertRule rule} if the list has only 1 rule inside,
+ * otherwise an {@link CombinatorExpertRule OR combinator} with the rules.
+ */
+ @Nonnull
+ public static Optional buildOrCombination(@Nullable final List rules) {
+ if (rules == null || rules.isEmpty()) {
+ return Optional.empty();
+ }
+ return Optional.of(rules.size() > 1 ? CombinatorExpertRule.builder().combinator(CombinatorType.OR).rules(rules).build() : rules.getFirst());
+ }
+
+ /**
+ * Builds expert filter with {@link VoltageLevel voltage level} IDs criteria.
+ */
+ @Nonnull
+ public static ExpertFilter buildExpertFilterWithVoltageLevelIdsCriteria(@Nonnull final UUID filterUuid, @Nonnull final EquipmentType equipmentType) {
+ return new ExpertFilter(UuidUtils.generateUUID(), TimeUtils.nowAsDate(), equipmentType,
+ CombinatorExpertRule.builder().combinator(CombinatorType.OR).rules(List.of(
+ FilterUuidExpertRule.builder().operator(OperatorType.IS_PART_OF).field(FieldType.VOLTAGE_LEVEL_ID_1).values(Set.of(filterUuid.toString())).build(),
+ FilterUuidExpertRule.builder().operator(OperatorType.IS_PART_OF).field(FieldType.VOLTAGE_LEVEL_ID_2).values(Set.of(filterUuid.toString())).build()
+ )).build());
+ }
}
diff --git a/src/test/java/org/gridsuite/filter/globalfilter/GlobalFilterUtilsTest.java b/src/test/java/org/gridsuite/filter/globalfilter/GlobalFilterUtilsTest.java
new file mode 100644
index 0000000..f6fcded
--- /dev/null
+++ b/src/test/java/org/gridsuite/filter/globalfilter/GlobalFilterUtilsTest.java
@@ -0,0 +1,355 @@
+package org.gridsuite.filter.globalfilter;
+
+import com.powsybl.iidm.network.Country;
+import com.powsybl.iidm.network.Identifiable;
+import com.powsybl.iidm.network.Network;
+import org.assertj.core.api.*;
+import org.gridsuite.filter.AbstractFilter;
+import org.gridsuite.filter.FilterLoader;
+import org.gridsuite.filter.expertfilter.ExpertFilter;
+import org.gridsuite.filter.expertfilter.expertrule.*;
+import org.gridsuite.filter.utils.EquipmentType;
+import org.gridsuite.filter.utils.FiltersUtils;
+import org.gridsuite.filter.utils.UuidUtils;
+import org.gridsuite.filter.utils.expertfilter.CombinatorType;
+import org.gridsuite.filter.utils.expertfilter.FieldType;
+import org.gridsuite.filter.utils.expertfilter.OperatorType;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.when;
+
+/* Methods dependencies:
+ * applyGlobalFilterOnNetwork
+ * ↳ applyGlobalFilterOnNetwork
+ * ↳ applyFilterOnNetwork
+ * ⇃ ↳ filterNetwork
+ * ↳ buildExpertFilter
+ * ↳ buildNominalVoltageRules
+ * ⇃ ↳ getNominalVoltageFieldType
+ * ↳ buildCountryCodeRules
+ * ⇃ ↳ getCountryCodeFieldType
+ * ↳ buildSubstationPropertyRules
+ * ↳ getSubstationPropertiesFieldTypes
+ */
+class GlobalFilterUtilsTest implements WithAssertions {
+ private static void testVariableOrCombinationRules(final Optional result, final int inputSize,
+ final Class ruleClass, final ThrowingConsumer[] singleRuleAsserts,
+ final Iterable multiAssertElements) {
+ final OptionalAssert assertion = Assertions.assertThat(result).as("result");
+ if (inputSize <= 0) {
+ assertion.isEmpty();
+ } else {
+ assertion.isPresent();
+ if (inputSize == 1) {
+ assertion.get(InstanceOfAssertFactories.type(ruleClass))
+ .as("expert rule")
+ .satisfies(singleRuleAsserts);
+ } else {
+ assertion.get(InstanceOfAssertFactories.type(CombinatorExpertRule.class))
+ .as("combinator expert rule")
+ .satisfies(cer -> Assertions.assertThat(cer.getCombinator()).as("combinator").isEqualTo(CombinatorType.OR))
+ .extracting(CombinatorExpertRule::getRules, InstanceOfAssertFactories.list(AbstractExpertRule.class)).as("expert rules")
+ .containsExactlyInAnyOrderElementsOf(multiAssertElements);
+ }
+ }
+ }
+
+ /** Trick Java to create generic array */
+ @SafeVarargs
+ private static ThrowingConsumer[] createAssertArray(final ThrowingConsumer... assertions) {
+ return assertions;
+ }
+
+ @Nested
+ @DisplayName("buildNominalVoltageRules(...)")
+ class BuildNominalVoltageRules {
+ @ParameterizedTest
+ @MethodSource({"expertRulesData"})
+ void shouldCreateExpertRules(final List nominalVoltages) {
+ testVariableOrCombinationRules(
+ GlobalFilterUtils.buildNominalVoltageRules(nominalVoltages, EquipmentType.VOLTAGE_LEVEL),
+ nominalVoltages.size(),
+ NumberExpertRule.class,
+ createAssertArray(
+ ner -> assertThat(ner.getValue()).as("value").hasToString(nominalVoltages.getFirst()),
+ ner -> assertThat(ner.getField()).as("field").isEqualTo(FieldType.NOMINAL_VOLTAGE),
+ ner -> assertThat(ner.getOperator()).as("operator").isEqualTo(OperatorType.EQUALS)
+ ),
+ nominalVoltages.stream().map(nv -> NumberExpertRule.builder().value(Double.valueOf(nv))
+ .field(FieldType.NOMINAL_VOLTAGE).operator(OperatorType.EQUALS).build()).collect(Collectors.toUnmodifiableList()));
+ }
+
+ private static Stream expertRulesData() {
+ return Stream.of(
+ Arguments.of(List.of()),
+ Arguments.of(List.of("300.0")),
+ Arguments.of(List.of("400.0", "225.0"))
+ );
+ }
+ }
+
+ @Nested
+ @DisplayName("buildCountryCodeRules(...)")
+ class BuildCountryCodeRules {
+ @ParameterizedTest
+ @MethodSource({"enumRulesData"})
+ void shouldCreateEnumRules(final List countries) {
+ testVariableOrCombinationRules(
+ GlobalFilterUtils.buildCountryCodeRules(countries, EquipmentType.VOLTAGE_LEVEL),
+ countries.size(),
+ EnumExpertRule.class,
+ createAssertArray(
+ ner -> assertThat(ner.getValue()).as("value").hasToString(countries.getFirst().name()),
+ ner -> assertThat(ner.getField()).as("field").isEqualTo(FieldType.COUNTRY),
+ ner -> assertThat(ner.getOperator()).as("operator").isEqualTo(OperatorType.EQUALS)
+ ),
+ (List) countries.stream().map(c -> EnumExpertRule.builder().value(c.name())
+ .field(FieldType.COUNTRY).operator(OperatorType.EQUALS).build()).toList());
+ }
+
+ private static Stream enumRulesData() {
+ return Stream.of(
+ Arguments.of(List.of()),
+ Arguments.of(List.of(Country.YT)),
+ Arguments.of(List.of(Country.FR, Country.DE))
+ );
+ }
+ }
+
+ @Nested
+ @DisplayName("buildSubstationPropertyRules(...)")
+ class BuildSubstationPropertyRules {
+ @ParameterizedTest
+ @MethodSource({"propertiesRulesData"})
+ void shouldCreateCorrectPropertiesRules(final Map> properties) {
+ testVariableOrCombinationRules(
+ GlobalFilterUtils.buildSubstationPropertyRules(properties, EquipmentType.VOLTAGE_LEVEL),
+ properties.size(),
+ PropertiesExpertRule.class,
+ createAssertArray(
+ per -> assertThat(per.getCombinator()).as("combinator").isEqualTo(CombinatorType.OR),
+ per -> assertThat(per.getOperator()).as("operator").isEqualTo(OperatorType.IN),
+ per -> assertThat(per.getField()).as("field").isEqualTo(FieldType.SUBSTATION_PROPERTIES),
+ per -> assertThat(per.getPropertyName()).as("property name").isEqualTo("prop1"),
+ per -> assertThat(per.getPropertyValues()).as("property values").containsExactlyInAnyOrderElementsOf(properties.values().iterator().next())
+ ),
+ (List) properties.entrySet().stream().map(e -> PropertiesExpertRule.builder().combinator(CombinatorType.OR)
+ .operator(OperatorType.IN).field(FieldType.SUBSTATION_PROPERTIES).propertyName(e.getKey()).propertyValues(e.getValue()).build()).toList());
+ }
+
+ private static Stream propertiesRulesData() {
+ return Stream.of(
+ Arguments.of(Map.of()),
+ Arguments.of(Map.of("prop1", List.of("value0"))),
+ Arguments.of(Map.of("prop1", List.of("value1", "value2"), "prop2", List.of("value3")))
+ );
+ }
+ }
+
+ @ParameterizedTest(name = "{0}")
+ @MethodSource("nominalVoltageFieldTypeData")
+ void shouldReturnCorrectNominalVoltageFieldTypes(final EquipmentType equipmentType, final List expectedFields) {
+ assertThat(GlobalFilterUtils.getNominalVoltageFieldType(equipmentType))
+ .as("result").containsExactlyInAnyOrderElementsOf(expectedFields);
+ }
+
+ private static Stream nominalVoltageFieldTypeData() {
+ return Stream.of(
+ // Nominal voltage
+ Arguments.of(EquipmentType.LINE, List.of(FieldType.NOMINAL_VOLTAGE_1, FieldType.NOMINAL_VOLTAGE_2)),
+ Arguments.of(EquipmentType.TWO_WINDINGS_TRANSFORMER, List.of(FieldType.NOMINAL_VOLTAGE_1, FieldType.NOMINAL_VOLTAGE_2)),
+ Arguments.of(EquipmentType.VOLTAGE_LEVEL, List.of(FieldType.NOMINAL_VOLTAGE)),
+ Arguments.of(EquipmentType.GENERATOR, Collections.emptyList())
+ );
+ }
+
+ @ParameterizedTest(name = "{0}")
+ @MethodSource("countryCodeFieldTypeData")
+ void shouldReturnCorrectCountryCodeFieldTypes(final EquipmentType equipmentType, final List expectedFields) {
+ assertThat(GlobalFilterUtils.getCountryCodeFieldType(equipmentType))
+ .as("result").containsExactlyInAnyOrderElementsOf(expectedFields);
+ }
+
+ private static Stream countryCodeFieldTypeData() {
+ return Stream.of(
+ // Country code
+ Arguments.of(EquipmentType.VOLTAGE_LEVEL, List.of(FieldType.COUNTRY)),
+ Arguments.of(EquipmentType.TWO_WINDINGS_TRANSFORMER, List.of(FieldType.COUNTRY)),
+ Arguments.of(EquipmentType.LINE, List.of(FieldType.COUNTRY_1, FieldType.COUNTRY_2)),
+ Arguments.of(EquipmentType.GENERATOR, Collections.emptyList())
+ );
+ }
+
+ @ParameterizedTest(name = "{0}")
+ @MethodSource("substationPropertyFieldTypeData")
+ void shouldReturnCorrectSubstationPropertyFieldTypes(final EquipmentType equipmentType, final List expectedFields) {
+ assertThat(GlobalFilterUtils.getSubstationPropertiesFieldTypes(equipmentType))
+ .as("result").containsExactlyInAnyOrderElementsOf(expectedFields);
+ }
+
+ private static Stream substationPropertyFieldTypeData() {
+ return Stream.of(
+ // Substation properties
+ Arguments.of(EquipmentType.LINE, List.of(FieldType.SUBSTATION_PROPERTIES_1, FieldType.SUBSTATION_PROPERTIES_2)),
+ Arguments.of(EquipmentType.GENERATOR, List.of(FieldType.SUBSTATION_PROPERTIES))
+ );
+ }
+
+ @Nested
+ @DisplayName("buildExpertFilter(...)")
+ class BuildExpertFilter {
+ @Test
+ void shouldReturnNullWhenNoExpertFiltersProvided() {
+ final GlobalFilter globalFilter = new GlobalFilter(null, null, null, null);
+ assertThat(GlobalFilterUtils.buildExpertFilter(globalFilter, EquipmentType.GENERATOR))
+ .as("result").isNull();
+ }
+
+ @Test
+ void shouldReturnNullWhenNoRules() {
+ final GlobalFilter globalFilter = new GlobalFilter(List.of(), List.of(), List.of(), Map.of());
+ assertThat(GlobalFilterUtils.buildExpertFilter(globalFilter, EquipmentType.GENERATOR))
+ .as("result").isNull();
+ }
+
+ @Test
+ void shouldCreateFilterWhenRulesExist() {
+ final List nv = List.of("400.0");
+ final GlobalFilter globalFilter = Mockito.spy(new GlobalFilter(nv, null, null, null));
+ try (final MockedStatic mockedGFU = Mockito.mockStatic(GlobalFilterUtils.class, Mockito.CALLS_REAL_METHODS)) {
+ mockedGFU.when(() -> GlobalFilterUtils.buildNominalVoltageRules(nv, EquipmentType.GENERATOR))
+ .thenReturn(Optional.of(Mockito.mock(AbstractExpertRule.class)));
+ mockedGFU.clearInvocations(); //important because stubbing static method counts as call
+ assertThat(GlobalFilterUtils.buildExpertFilter(globalFilter, EquipmentType.GENERATOR)).as("result")
+ .isNotNull().satisfies(
+ ef -> assertThat(ef.getEquipmentType()).as("equipment type").isEqualTo(EquipmentType.GENERATOR),
+ ef -> assertThat(ef.getRules()).as("rule combinator")
+ .asInstanceOf(InstanceOfAssertFactories.type(CombinatorExpertRule.class))
+ .extracting(CombinatorExpertRule::getRules, InstanceOfAssertFactories.list(AbstractExpertRule.class))
+ .as("rules").hasSize(1)
+ );
+ Mockito.verify(globalFilter, Mockito.atLeastOnce()).getNominalV();
+ Mockito.verify(globalFilter, Mockito.atLeastOnce()).getCountryCode();
+ Mockito.verify(globalFilter, Mockito.atLeastOnce()).getSubstationProperty();
+ mockedGFU.verify(() -> GlobalFilterUtils.buildNominalVoltageRules(Mockito.anyList(), any(EquipmentType.class)), Mockito.times(1));
+ mockedGFU.verify(() -> GlobalFilterUtils.buildExpertFilter(any(GlobalFilter.class), any(EquipmentType.class)), Mockito.times(1));
+ mockedGFU.verifyNoMoreInteractions(); //check if forget to mock a method
+ Mockito.verifyNoMoreInteractions(globalFilter);
+ }
+ }
+ }
+
+ @Nested
+ @DisplayName("filterNetwork(...)")
+ class FilterNetwork {
+ @Test
+ void shouldReturnIdsFromFilteredNetwork() {
+ final Network network = Mockito.mock(Network.class);
+ final FilterLoader loader = Mockito.mock(FilterLoader.class);
+ final AbstractFilter filter = Mockito.mock(AbstractFilter.class);
+ when(filter.getEquipmentType()).thenReturn(EquipmentType.GENERATOR);
+ try (final MockedStatic mockedFU = Mockito.mockStatic(FiltersUtils.class, Mockito.CALLS_REAL_METHODS)) {
+ final Identifiable i1 = Mockito.mock(Identifiable.class);
+ when(i1.getId()).thenReturn("id1");
+ final Identifiable i2 = Mockito.mock(Identifiable.class);
+ when(i2.getId()).thenReturn("id2");
+ final List> attributes = List.of(i1, i2);
+ mockedFU.when(() -> FiltersUtils.getIdentifiables(filter, network, loader)).thenReturn(attributes);
+ mockedFU.clearInvocations(); //important because stubbing static method counts as call
+ assertThat(GlobalFilterUtils.filterNetwork(filter, network, loader)).as("result")
+ .containsExactlyInAnyOrder("id1", "id2");
+ Mockito.verify(i1, Mockito.atLeastOnce()).getId();
+ Mockito.verify(i2, Mockito.atLeastOnce()).getId();
+ Mockito.verify(filter, Mockito.atLeastOnce()).getEquipmentType();
+ Mockito.verifyNoMoreInteractions(filter, network, loader, i1, i2);
+ mockedFU.verify(() -> FiltersUtils.getIdentifiables(eq(filter), eq(network), eq(loader)), Mockito.times(1));
+ mockedFU.verifyNoMoreInteractions(); //check if forget to mock a method
+ }
+ }
+ }
+
+ @Nested
+ @DisplayName("applyFilterOnNetwork(...)")
+ class ApplyFilterOnNetwork {
+ @Test
+ void shouldReturnFilteredNetworkWhenSameEquipmentType() {
+ final Network network = Mockito.mock(Network.class);
+ final FilterLoader loader = Mockito.mock(FilterLoader.class);
+ final AbstractFilter filter = Mockito.mock(AbstractFilter.class);
+ when(filter.getEquipmentType()).thenReturn(EquipmentType.GENERATOR);
+ try (final MockedStatic mockedFU = Mockito.mockStatic(FiltersUtils.class, Mockito.CALLS_REAL_METHODS)) {
+ final Identifiable gen1 = Mockito.mock(Identifiable.class);
+ when(gen1.getId()).thenReturn("gen1");
+ final Identifiable gen2 = Mockito.mock(Identifiable.class);
+ when(gen2.getId()).thenReturn("gen2");
+ final List> attributes = List.of(gen1, gen2);
+ mockedFU.when(() -> FiltersUtils.getIdentifiables(filter, network, loader)).thenReturn(attributes);
+ mockedFU.clearInvocations(); //important because stubbing static method counts as call
+ assertThat(GlobalFilterUtils.applyFilterOnNetwork(filter, EquipmentType.GENERATOR, network, loader))
+ .as("result").containsExactlyInAnyOrder("gen1", "gen2");
+ Mockito.verify(filter, Mockito.atLeastOnce()).getEquipmentType();
+ Mockito.verify(gen1, Mockito.atLeastOnce()).getId();
+ Mockito.verify(gen2, Mockito.atLeastOnce()).getId();
+ Mockito.verifyNoMoreInteractions(filter, network, loader, gen1, gen2);
+ mockedFU.verify(() -> FiltersUtils.getIdentifiables(eq(filter), eq(network), eq(loader)), Mockito.atLeastOnce());
+ mockedFU.verifyNoMoreInteractions(); //check if forget to mock a method
+ }
+ }
+
+ @Test
+ void shouldBuildVoltageLevelFilterWhenVoltageLevelType() {
+ final Network network = Mockito.mock(Network.class);
+ final FilterLoader loader = Mockito.mock(FilterLoader.class);
+ final AbstractFilter filter = Mockito.mock(AbstractFilter.class);
+ when(filter.getEquipmentType()).thenReturn(EquipmentType.VOLTAGE_LEVEL);
+ final UUID filterUuid = UuidUtils.createUUID(0);
+ when(filter.getId()).thenReturn(filterUuid);
+ try (final MockedStatic mockedFU = Mockito.mockStatic(FiltersUtils.class, Mockito.CALLS_REAL_METHODS)) {
+ final Identifiable line1 = Mockito.mock(Identifiable.class);
+ when(line1.getId()).thenReturn("line1");
+ final Identifiable line2 = Mockito.mock(Identifiable.class);
+ when(line2.getId()).thenReturn("line2");
+ final List> attributes = List.of(line1, line2);
+ mockedFU.when(() -> FiltersUtils.getIdentifiables(any(ExpertFilter.class), eq(network), eq(loader))).thenReturn(attributes);
+ mockedFU.clearInvocations(); //important because stubbing static method counts as call
+ assertThat(GlobalFilterUtils.applyFilterOnNetwork(filter, EquipmentType.LINE, network, loader))
+ .as("result").containsExactlyInAnyOrder("line1", "line2");
+ Mockito.verify(filter, Mockito.atLeastOnce()).getEquipmentType();
+ Mockito.verify(filter, Mockito.atLeastOnce()).getId();
+ Mockito.verify(line1, Mockito.atLeastOnce()).getId();
+ Mockito.verify(line2, Mockito.atLeastOnce()).getId();
+ Mockito.verifyNoMoreInteractions(filter, network, loader, line1, line2);
+ mockedFU.verify(() -> FiltersUtils.getIdentifiables(any(ExpertFilter.class), eq(network), eq(loader)), Mockito.atLeastOnce());
+ mockedFU.verifyNoMoreInteractions(); //check if forget to mock a method
+ }
+ }
+
+ @Test
+ void shouldReturnEmptyWhenDifferentEquipmentType() {
+ final FilterLoader loader = Mockito.mock(FilterLoader.class);
+ final Network network = Mockito.mock(Network.class);
+ final AbstractFilter filter = Mockito.mock(AbstractFilter.class);
+ when(filter.getEquipmentType()).thenReturn(EquipmentType.LOAD);
+ assertThat(GlobalFilterUtils.applyFilterOnNetwork(filter, EquipmentType.GENERATOR, network, loader))
+ .as("result").isEmpty();
+ Mockito.verify(filter, Mockito.atLeastOnce()).getEquipmentType();
+ Mockito.verifyNoMoreInteractions(loader, network, filter);
+ }
+ }
+
+ //TODO applyGlobalFilterOnNetwork(single)
+ //TODO applyGlobalFilterOnNetwork(list)
+}
diff --git a/src/test/java/org/gridsuite/filter/utils/FiltersUtilsTest.java b/src/test/java/org/gridsuite/filter/utils/FiltersUtilsTest.java
index 6a9f279..f657ddc 100644
--- a/src/test/java/org/gridsuite/filter/utils/FiltersUtilsTest.java
+++ b/src/test/java/org/gridsuite/filter/utils/FiltersUtilsTest.java
@@ -9,42 +9,32 @@
import com.powsybl.iidm.network.*;
import com.powsybl.iidm.network.test.*;
import org.apache.commons.collections4.CollectionUtils;
+import org.assertj.core.api.WithAssertions;
import org.gridsuite.filter.FilterLoader;
import org.gridsuite.filter.expertfilter.ExpertFilter;
import org.gridsuite.filter.expertfilter.expertrule.AbstractExpertRule;
import org.gridsuite.filter.expertfilter.expertrule.CombinatorExpertRule;
import org.gridsuite.filter.expertfilter.expertrule.StringExpertRule;
-import org.gridsuite.filter.identifierlistfilter.FilterEquipments;
-import org.gridsuite.filter.identifierlistfilter.FilteredIdentifiables;
-import org.gridsuite.filter.identifierlistfilter.IdentifiableAttributes;
-import org.gridsuite.filter.identifierlistfilter.IdentifierListFilter;
-import org.gridsuite.filter.identifierlistfilter.IdentifierListFilterEquipmentAttributes;
+import org.gridsuite.filter.identifierlistfilter.*;
import org.gridsuite.filter.utils.expertfilter.CombinatorType;
import org.gridsuite.filter.utils.expertfilter.OperatorType;
-import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.util.*;
-import static org.gridsuite.filter.utils.expertfilter.FieldType.*;
-import static org.gridsuite.filter.utils.expertfilter.OperatorType.*;
+import static org.gridsuite.filter.utils.expertfilter.FieldType.ID;
+import static org.gridsuite.filter.utils.expertfilter.FieldType.NAME;
+import static org.gridsuite.filter.utils.expertfilter.OperatorType.IS;
import static org.junit.jupiter.api.Assertions.*;
/**
* @author Franck Lecuyer
*/
-class FiltersUtilsTest {
- private Network network;
- private Network network2;
- private Network network3;
- private Network network4;
- private Network network5;
-
- private FilterLoader filterLoader;
-
- @BeforeEach
- void setUp() {
- network = EurostagTutorialExample1Factory.createWithMoreGenerators();
+class FiltersUtilsTest implements WithAssertions {
+ private final FilterLoader filterLoader = uuids -> null;
+
+ private static Network prepareNetwork() {
+ Network network = EurostagTutorialExample1Factory.createWithMoreGenerators();
network.getSubstation("P1").setProperty("region", "north");
network.getSubstation("P2").setProperty("region", "south");
network.getGenerator("GEN").setProperty("region", "north");
@@ -54,17 +44,18 @@ void setUp() {
network.getTwoWindingsTransformer("NHV2_NLOAD").setProperty("region", "south");
network.getLine("NHV1_NHV2_1").setProperty("region", "south");
network.getLine("NHV1_NHV2_2").setProperty("region", "south");
+ return network;
+ }
- network2 = HvdcTestNetwork.createVsc();
+ private static Network prepareHvdcNetwork() {
+ Network network2 = HvdcTestNetwork.createVsc();
network2.getSubstation("S2").setProperty("region", "north");
- network3 = SvcTestCaseFactory.createWithMoreSVCs();
- network4 = ShuntTestCaseFactory.create();
- network5 = ThreeWindingsTransformerNetworkFactory.create();
- filterLoader = uuids -> null;
+ return network2;
}
@Test
void testSubstationFilter() {
+ final Network network = prepareNetwork();
// identifier list filter
List filterEquipmentAttributes = List.of(
@@ -95,6 +86,7 @@ void testSubstationFilter() {
@Test
void testVoltageLevelFilter() {
+ final Network network = prepareNetwork();
// identifier list filter
List filterEquipmentAttributes = List.of(
@@ -124,6 +116,7 @@ void testVoltageLevelFilter() {
@Test
void testLineFilter() {
+ final Network network = prepareNetwork();
// identifier list filter
List filterEquipmentAttributes = List.of(
@@ -155,6 +148,7 @@ void testLineFilter() {
@Test
void testTwoWindingsTransformerFilter() {
+ final Network network = prepareNetwork();
// identifier list filter
List filterEquipmentAttributes = List.of(
@@ -184,6 +178,7 @@ void testTwoWindingsTransformerFilter() {
@Test
void testThreeWindingsTransformerFilter() {
+ final Network network5 = ThreeWindingsTransformerNetworkFactory.create();
// expert filter
ExpertFilter expertFilter = new ExpertFilter(
@@ -200,6 +195,7 @@ void testThreeWindingsTransformerFilter() {
@Test
void testGeneratorFilter() {
+ final Network network = prepareNetwork();
// identifier list filter
List filterEquipmentAttributes = List.of(
@@ -232,6 +228,7 @@ void testGeneratorFilter() {
@Test
void testLoadFilter() {
+ final Network network = prepareNetwork();
// identifier list filter
List filterEquipmentAttributes = List.of(
@@ -261,6 +258,7 @@ void testLoadFilter() {
@Test
void testBatteryFilter() {
+ final Network network = prepareNetwork();
// identifier list filter
List filterEquipmentAttributes = List.of(
@@ -288,6 +286,7 @@ void testBatteryFilter() {
@Test
void testShuntCompensatorFilter() {
+ final Network network4 = ShuntTestCaseFactory.create();
// identifier list filter
List filterEquipmentAttributes = List.of(
@@ -317,6 +316,7 @@ void testShuntCompensatorFilter() {
@Test
void testStaticVarCompensatorFilter() {
+ final Network network3 = SvcTestCaseFactory.createWithMoreSVCs();
// identifier list filter
List filterEquipmentAttributes = List.of(
@@ -349,6 +349,7 @@ void testStaticVarCompensatorFilter() {
@Test
void testDanglingLineFilter() {
+ final Network network = prepareNetwork();
// identifier list filter
List filterEquipmentAttributes = List.of(
@@ -376,6 +377,7 @@ void testDanglingLineFilter() {
@Test
void testBusbarSectionFilter() {
+ final Network network = prepareNetwork();
// identifier list filter
List filterEquipmentAttributes = List.of(
@@ -403,6 +405,8 @@ void testBusbarSectionFilter() {
@Test
void testBusFilter() {
+ final Network network = prepareNetwork();
+
// expert filter only for bus
ExpertFilter expertFilter = new ExpertFilter(
UUID.randomUUID(),
@@ -417,6 +421,7 @@ void testBusFilter() {
@Test
void testLccConverterStationFilter() {
+ final Network network = prepareNetwork();
// identifier list filter
List filterEquipmentAttributes = List.of(
@@ -444,6 +449,7 @@ void testLccConverterStationFilter() {
@Test
void testHvdcLineFilter() {
+ final Network network2 = prepareHvdcNetwork();
// identifier list filter
List filterEquipmentAttributes = List.of(
@@ -474,6 +480,7 @@ void testHvdcLineFilter() {
@Test
void testIdentifierListFilter() {
+ final Network network = prepareNetwork();
List filterEquipmentAttributes = List.of(
new IdentifierListFilterEquipmentAttributes("GEN", 30.),
new IdentifierListFilterEquipmentAttributes("notFound1", 50.),
@@ -513,6 +520,7 @@ void testIdentifierListFilter() {
@Test
void testFilterLoader() {
+ final Network network = prepareNetwork();
// with identifier list filter
List filterEquipmentAttributes = List.of(
new IdentifierListFilterEquipmentAttributes("GEN", 30.),
@@ -539,6 +547,7 @@ void testFilterLoader() {
@Test
void testEquipmentNameFilterNoMatch() {
+ final Network network2 = prepareHvdcNetwork();
List rules = new ArrayList<>();
rules.add(StringExpertRule.builder().field(NAME).operator(IS).value("unexisting name").build());
AbstractExpertRule parentRule = CombinatorExpertRule.builder().combinator(CombinatorType.AND).rules(rules).build();
@@ -555,6 +564,7 @@ void testEquipmentNameFilterNoMatch() {
@Test
void testEquipmentNameFilterWithMatch() {
+ final Network network2 = prepareHvdcNetwork();
List rules = new ArrayList<>();
rules.add(StringExpertRule.builder().field(NAME).operator(IS).value("Converter1").build());
AbstractExpertRule parentRule = CombinatorExpertRule.builder().combinator(CombinatorType.AND).rules(rules).build();
@@ -570,6 +580,7 @@ void testEquipmentNameFilterWithMatch() {
@Test
void testEquipmentNameFilterWithNullValueInEquipments() {
+ final Network network = prepareNetwork();
List rules = new ArrayList<>();
rules.add(StringExpertRule.builder().field(NAME).operator(IS).value("some name").build());
AbstractExpertRule parentRule = CombinatorExpertRule.builder().combinator(CombinatorType.AND).rules(rules).build();
@@ -583,4 +594,27 @@ void testEquipmentNameFilterWithNullValueInEquipments() {
// in this network, VL equipments have null name => no match
assertEquals(0, identifiables.size());
}
+
+ @Test
+ void shouldReturnEmptyWhenCombineFilterResultsInputIsEmpty() {
+ assertThat(FiltersUtils.combineFilterResults(List.of(), true)).as("result").isEmpty();
+ }
+
+ @Test
+ void shouldReturnIntersectionWhenUsingAndLogic() {
+ assertThat(FiltersUtils.combineFilterResults(Arrays.asList(
+ List.of("item1", "item2", "item3"),
+ List.of("item2", "item3", "item4"),
+ List.of("item2", "item5")), true))
+ .as("result").singleElement().isEqualTo("item2");
+ }
+
+ @Test
+ void shouldReturnUnionWhenUsingOrLogic() {
+ assertThat(FiltersUtils.combineFilterResults(Arrays.asList(
+ List.of("item1", "item2"),
+ List.of("item3", "item4"),
+ List.of("item5")), false))
+ .as("result").containsExactlyInAnyOrder("item1", "item2", "item3", "item4", "item5");
+ }
}
diff --git a/src/test/java/org/gridsuite/filter/utils/expertfilter/ExpertFilterUtilsTest.java b/src/test/java/org/gridsuite/filter/utils/expertfilter/ExpertFilterUtilsTest.java
new file mode 100644
index 0000000..2de5c5c
--- /dev/null
+++ b/src/test/java/org/gridsuite/filter/utils/expertfilter/ExpertFilterUtilsTest.java
@@ -0,0 +1,71 @@
+package org.gridsuite.filter.utils.expertfilter;
+
+import org.assertj.core.api.InstanceOfAssertFactories;
+import org.assertj.core.api.OptionalAssert;
+import org.assertj.core.api.WithAssertions;
+import org.gridsuite.filter.expertfilter.expertrule.AbstractExpertRule;
+import org.gridsuite.filter.expertfilter.expertrule.CombinatorExpertRule;
+import org.gridsuite.filter.expertfilter.expertrule.FilterUuidExpertRule;
+import org.gridsuite.filter.utils.EquipmentType;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.util.List;
+import java.util.UUID;
+import java.util.stream.Stream;
+
+import static org.mockito.Mockito.mock;
+
+class ExpertFilterUtilsTest implements WithAssertions {
+ @ParameterizedTest
+ @MethodSource("orCombinationData")
+ void shouldCreateOrCombination(final List rules, final boolean expectEmpty, final boolean expectSingle) {
+ final OptionalAssert assertOpt = assertThat(ExpertFilterUtils.buildOrCombination(rules)).as("result");
+ if (expectEmpty) {
+ assertOpt.isEmpty();
+ } else {
+ assertOpt.isPresent();
+ final var assertRule = assertOpt.get().as("rule");
+ if (expectSingle) {
+ assertRule.isEqualTo(rules.getFirst());
+ } else {
+ assertRule.asInstanceOf(InstanceOfAssertFactories.type(CombinatorExpertRule.class)).satisfies(
+ cer -> assertThat(cer.getCombinator()).as("combinator").isEqualTo(CombinatorType.OR),
+ cer -> assertThat(cer.getRules()).as("rules").containsExactlyInAnyOrderElementsOf(rules)
+ );
+ }
+ }
+ }
+
+ private static Stream orCombinationData() {
+ return Stream.of(
+ Arguments.of(List.of(), true, false),
+ Arguments.of(List.of(mock(AbstractExpertRule.class)), false, true),
+ Arguments.of(List.of(mock(AbstractExpertRule.class), mock(AbstractExpertRule.class)), false, false)
+ );
+ }
+
+ @Test
+ void shouldCreateExpertFilterWithVoltageLevelIdsCriteria() {
+ final UUID filterUuid = UUID.randomUUID();
+ final EquipmentType equipmentType = EquipmentType.LINE;
+ assertThat(ExpertFilterUtils.buildExpertFilterWithVoltageLevelIdsCriteria(filterUuid, equipmentType)).as("result").isNotNull().satisfies(
+ ef -> assertThat(ef.getEquipmentType()).as("equipmentType").isEqualTo(equipmentType),
+ ef -> assertThat(ef.getRules()).as("expert rules").isNotNull()
+ .asInstanceOf(InstanceOfAssertFactories.type(CombinatorExpertRule.class))
+ .satisfies(
+ cer -> assertThat(cer.getCombinator()).as("combinator").isEqualTo(CombinatorType.OR),
+ cer -> assertThat(cer.getRules()).as("combinator rules").hasSize(2)
+ .allSatisfy(er -> assertThat(er).as("expert rule")
+ .asInstanceOf(InstanceOfAssertFactories.type(FilterUuidExpertRule.class))
+ .satisfies(fuer -> assertThat(fuer.getOperator()).as("operator").isEqualTo(OperatorType.IS_PART_OF))
+ .extracting(FilterUuidExpertRule::getValues, InstanceOfAssertFactories.set(String.class)).as("UUIDs")
+ .containsExactly(filterUuid.toString()))
+ .map(AbstractExpertRule::getField).as("fields")
+ .containsExactly(FieldType.VOLTAGE_LEVEL_ID_1, FieldType.VOLTAGE_LEVEL_ID_2)
+ )
+ );
+ }
+}