diff --git a/src/main/java/org/gridsuite/computation/dto/GlobalFilter.java b/src/main/java/org/gridsuite/computation/dto/GlobalFilter.java index be33412..d3dab5b 100644 --- a/src/main/java/org/gridsuite/computation/dto/GlobalFilter.java +++ b/src/main/java/org/gridsuite/computation/dto/GlobalFilter.java @@ -12,6 +12,7 @@ import lombok.Builder; import lombok.Getter; import lombok.NoArgsConstructor; +import lombok.experimental.FieldNameConstants; import java.util.List; import java.util.Map; @@ -24,6 +25,7 @@ @Builder @AllArgsConstructor @NoArgsConstructor +@FieldNameConstants public class GlobalFilter { List nominalV; diff --git a/src/test/java/org/gridsuite/computation/service/FilterServiceTest.java b/src/test/java/org/gridsuite/computation/service/FilterServiceTest.java index 6615e17..e3386fb 100644 --- a/src/test/java/org/gridsuite/computation/service/FilterServiceTest.java +++ b/src/test/java/org/gridsuite/computation/service/FilterServiceTest.java @@ -25,8 +25,12 @@ 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.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import org.mockito.Mock; import org.mockito.MockedStatic; import org.mockito.junit.jupiter.MockitoExtension; @@ -40,6 +44,7 @@ import org.springframework.web.server.ResponseStatusException; import java.util.*; +import java.util.stream.Stream; import static org.junit.jupiter.api.Assertions.*; import static org.mockito.ArgumentMatchers.any; @@ -72,168 +77,131 @@ class FilterServiceTest { private static final UUID NETWORK_UUID = UUID.randomUUID(); private static final UUID FILTER_UUID = UUID.randomUUID(); + @BeforeEach + void setUp() { + ReflectionTestUtils.setField(filterService, "restTemplate", restTemplate); + ReflectionTestUtils.setField(filterService, "filterServerBaseUri", FILTER_SERVER_BASE_URI); + ReflectionTestUtils.setField(filterService, "networkStoreService", networkStoreService); + } + @Test void shouldReturnEmptyListWhenFiltersUuidsIsEmpty() { - // Given when(filterService.getFilters(anyList())).thenCallRealMethod(); List emptyList = Collections.emptyList(); - - // When List result = filterService.getFilters(emptyList); - - // Then - assertNotNull(result); - assertTrue(result.isEmpty()); - } - - @Test - void shouldReturnEmptyListWhenFiltersUuidsIsNull() { - // Given - when(filterService.getFilters(any())).thenCallRealMethod(); - - // When - List result = filterService.getFilters(null); - - // Then assertNotNull(result); assertTrue(result.isEmpty()); } @Test - void houldCallRestTemplateAndReturnFilters() { - // Given + void shouldCallRestTemplateAndReturnFilters() { when(filterService.getFilters(anyList())).thenCallRealMethod(); - ReflectionTestUtils.setField(filterService, "restTemplate", restTemplate); - ReflectionTestUtils.setField(filterService, "filterServerBaseUri", FILTER_SERVER_BASE_URI); - List filterUuids = List.of(FILTER_UUID); List expectedFilters = Collections.singletonList(mock(AbstractFilter.class)); - ResponseEntity> responseEntity = new ResponseEntity<>(expectedFilters, HttpStatus.OK); when(restTemplate.exchange(anyString(), eq(HttpMethod.GET), isNull(), any(ParameterizedTypeReference.class))).thenReturn(responseEntity); - - // When List result = filterService.getFilters(filterUuids); - - // Then assertEquals(expectedFilters, result); - verify(restTemplate).exchange( - contains("v1/filters/metadata"), - eq(HttpMethod.GET), - isNull(), - any(ParameterizedTypeReference.class) + verify(restTemplate).exchange(contains("v1/filters/metadata"), eq(HttpMethod.GET), isNull(), any(ParameterizedTypeReference.class) ); } @Test void shouldThrowPowsyblExceptionWhenHttpError() { - // Given when(filterService.getFilters(anyList())).thenCallRealMethod(); - ReflectionTestUtils.setField(filterService, "restTemplate", restTemplate); - ReflectionTestUtils.setField(filterService, "filterServerBaseUri", FILTER_SERVER_BASE_URI); - List filterUuids = List.of(FILTER_UUID); - HttpStatusCodeException httpException = mock(HttpStatusCodeException.class); - when(restTemplate.exchange( - anyString(), - eq(HttpMethod.GET), - isNull(), - any(ParameterizedTypeReference.class) + when(restTemplate.exchange(anyString(), eq(HttpMethod.GET), isNull(), any(ParameterizedTypeReference.class) )).thenThrow(httpException); - - // When & Then - PowsyblException exception = assertThrows(PowsyblException.class, - () -> filterService.getFilters(filterUuids)); - + PowsyblException exception = assertThrows(PowsyblException.class, () -> filterService.getFilters(filterUuids)); assertTrue(exception.getMessage().contains("Filters not found")); assertTrue(exception.getMessage().contains(FILTER_UUID.toString())); } @Test void shouldReturnNetworkWhenSuccessful() { - // Given when(filterService.getNetwork(any(), any())).thenCallRealMethod(); - ReflectionTestUtils.setField(filterService, "networkStoreService", networkStoreService); - - when(networkStoreService.getNetwork(NETWORK_UUID, PreloadingStrategy.COLLECTION)) - .thenReturn(network); + when(networkStoreService.getNetwork(NETWORK_UUID, PreloadingStrategy.COLLECTION)).thenReturn(network); when(network.getVariantManager()).thenReturn(variantManager); - - // When Network result = filterService.getNetwork(NETWORK_UUID, VARIANT_ID); - - // Then assertEquals(network, result); verify(variantManager).setWorkingVariant(VARIANT_ID); } @Test void shouldThrowResponseStatusExceptionWhenPowsyblException() { - // Given when(filterService.getNetwork(any(), any())).thenCallRealMethod(); - ReflectionTestUtils.setField(filterService, "networkStoreService", networkStoreService); - PowsyblException powsyblException = new PowsyblException("Network not found"); - when(networkStoreService.getNetwork(NETWORK_UUID, PreloadingStrategy.COLLECTION)) - .thenThrow(powsyblException); - - // When & Then - ResponseStatusException exception = assertThrows(ResponseStatusException.class, - () -> filterService.getNetwork(NETWORK_UUID, VARIANT_ID)); - + when(networkStoreService.getNetwork(NETWORK_UUID, PreloadingStrategy.COLLECTION)).thenThrow(powsyblException); + ResponseStatusException exception = assertThrows(ResponseStatusException.class, () -> filterService.getNetwork(NETWORK_UUID, VARIANT_ID)); assertEquals(HttpStatus.NOT_FOUND, exception.getStatusCode()); assertEquals("Network not found", exception.getReason()); } - @Test - void shouldReturnEmptyListWhenNumberExpertRulesValuesIsNull() { - // Given + @ParameterizedTest + @MethodSource("expertRulesData") + void shouldCreateExpertRules(List values, FieldType fieldType, Class expectedRuleType, boolean shouldBeEmpty) { when(filterService.createNumberExpertRules(any(), any())).thenCallRealMethod(); - - // When - List result = filterService.createNumberExpertRules(null, FieldType.NOMINAL_VOLTAGE); - - // Then - assertNotNull(result); - assertTrue(result.isEmpty()); + List result = filterService.createNumberExpertRules(values, fieldType); + if (shouldBeEmpty) { + assertNotNull(result); + assertTrue(result.isEmpty()); + } else { + assertNotNull(result); + assertEquals(values.size(), result.size()); + for (AbstractExpertRule rule : result) { + assertInstanceOf(expectedRuleType, rule); + NumberExpertRule numberRule = (NumberExpertRule) rule; + assertEquals(fieldType, numberRule.getField()); + assertEquals(OperatorType.EQUALS, numberRule.getOperator()); + } + } } - @Test - void shouldCreateNumberExpertRulesWhenValuesProvided() { - // Given - when(filterService.createNumberExpertRules(any(), any())).thenCallRealMethod(); - List values = Arrays.asList("400.0", "225.0"); - - // When - List result = filterService.createNumberExpertRules(values, FieldType.NOMINAL_VOLTAGE); + private static Stream expertRulesData() { + return Stream.of( + Arguments.of(null, FieldType.NOMINAL_VOLTAGE, NumberExpertRule.class, true), + Arguments.of(Arrays.asList("400.0", "225.0"), FieldType.NOMINAL_VOLTAGE, NumberExpertRule.class, false) + ); + } - // Then - assertNotNull(result); - assertEquals(2, result.size()); + @ParameterizedTest + @MethodSource("enumRulesData") + void shouldCreateEnumRules(List values, FieldType fieldType, Class expectedRuleType, boolean shouldBeEmpty) { + when(filterService.createEnumExpertRules(any(), any())).thenCallRealMethod(); - for (AbstractExpertRule rule : result) { - assertInstanceOf(NumberExpertRule.class, rule); - NumberExpertRule numberRule = (NumberExpertRule) rule; - assertEquals(FieldType.NOMINAL_VOLTAGE, numberRule.getField()); - assertEquals(OperatorType.EQUALS, numberRule.getOperator()); + List result = filterService.createEnumExpertRules(values, fieldType); + + if (shouldBeEmpty) { + assertNotNull(result); + assertTrue(result.isEmpty()); + } else { + assertNotNull(result); + assertEquals(values.size(), result.size()); + for (AbstractExpertRule rule : result) { + assertInstanceOf(expectedRuleType, rule); + EnumExpertRule enumRule = (EnumExpertRule) rule; + assertEquals(fieldType, enumRule.getField()); + assertEquals(OperatorType.EQUALS, enumRule.getOperator()); + } } } + private static Stream enumRulesData() { + return Stream.of( + Arguments.of(null, FieldType.COUNTRY, EnumExpertRule.class, true), + Arguments.of(Arrays.asList(Country.FR, Country.DE), FieldType.COUNTRY, EnumExpertRule.class, false) + ); + } + @Test void shouldCreateCorrectPropertiesRule() { - // Given when(filterService.createPropertiesRule(any(), any(), any())).thenCallRealMethod(); String property = "testProperty"; List values = Arrays.asList("value1", "value2"); - - // When AbstractExpertRule result = filterService.createPropertiesRule(property, values, FieldType.SUBSTATION_PROPERTIES); - - // Then assertNotNull(result); assertInstanceOf(PropertiesExpertRule.class, result); - PropertiesExpertRule propertiesRule = (PropertiesExpertRule) result; assertEquals(CombinatorType.OR, propertiesRule.getCombinator()); assertEquals(OperatorType.IN, propertiesRule.getOperator()); @@ -242,242 +210,171 @@ void shouldCreateCorrectPropertiesRule() { assertEquals(values, propertiesRule.getPropertyValues()); } - @Test - void shouldReturnEmptyListWhenEnumExpertRulesValuesIsNull() { - // Given - when(filterService.createEnumExpertRules(any(), any())).thenCallRealMethod(); - - // When - List result = filterService.createEnumExpertRules(null, FieldType.COUNTRY); - - // Then - assertNotNull(result); - assertTrue(result.isEmpty()); - } - - @Test - void shouldCreateRulesWhenValuesProvided() { - // Given - when(filterService.createEnumExpertRules(any(), any())).thenCallRealMethod(); - List values = Arrays.asList(Country.FR, Country.DE); - - // When - List result = filterService.createEnumExpertRules(values, FieldType.COUNTRY); - - // Then - assertNotNull(result); - assertEquals(2, result.size()); - - for (AbstractExpertRule rule : result) { - assertInstanceOf(EnumExpertRule.class, rule); - EnumExpertRule enumRule = (EnumExpertRule) rule; - assertEquals(FieldType.COUNTRY, enumRule.getField()); - assertEquals(OperatorType.EQUALS, enumRule.getOperator()); - } - } - @Test void shouldCreateCombinatorRule() { - // Given when(filterService.createCombination(any(), any())).thenCallRealMethod(); List rules = Collections.singletonList(mock(AbstractExpertRule.class)); - - // When AbstractExpertRule result = filterService.createCombination(CombinatorType.AND, rules); - - // Then assertNotNull(result); assertInstanceOf(CombinatorExpertRule.class, result); - CombinatorExpertRule combinatorRule = (CombinatorExpertRule) result; assertEquals(CombinatorType.AND, combinatorRule.getCombinator()); assertEquals(rules, combinatorRule.getRules()); } - @Test - void shouldReturnEmptyWhenRulesIsEmpty() { - // Given - when(filterService.createOrCombination(any())).thenCallRealMethod(); - List rules = Collections.emptyList(); - - // When - Optional result = filterService.createOrCombination(rules); - - // Then - assertFalse(result.isPresent()); - } - - @Test - void shouldReturnSingleRuleWhenOnlyOneRule() { - // Given + @ParameterizedTest + @MethodSource("orCombinationData") + void shouldCreateOrCombination(List rules, boolean expectEmpty, boolean expectSingle) { when(filterService.createOrCombination(any())).thenCallRealMethod(); - - AbstractExpertRule rule = mock(AbstractExpertRule.class); - List rules = Collections.singletonList(rule); - - // When + if (!expectEmpty && !expectSingle) { + when(filterService.createCombination(any(), any())).thenCallRealMethod(); + } Optional result = filterService.createOrCombination(rules); - - // Then - assertTrue(result.isPresent()); - assertEquals(rule, result.get()); + if (expectEmpty) { + assertFalse(result.isPresent()); + } else if (expectSingle) { + assertTrue(result.isPresent()); + assertEquals(rules.getFirst(), result.get()); + } else { + assertTrue(result.isPresent()); + assertInstanceOf(CombinatorExpertRule.class, result.get()); + CombinatorExpertRule combinatorRule = (CombinatorExpertRule) result.get(); + assertEquals(CombinatorType.OR, combinatorRule.getCombinator()); + } } - @Test - void shouldReturnCombinatorWhenMultipleRules() { - // Given - when(filterService.createOrCombination(any())).thenCallRealMethod(); - when(filterService.createCombination(any(), any())).thenCallRealMethod(); - - List rules = Arrays.asList( - mock(AbstractExpertRule.class), - mock(AbstractExpertRule.class) + private static Stream orCombinationData() { + return Stream.of( + Arguments.of(Collections.emptyList(), true, false), + Arguments.of(Collections.singletonList(mock(AbstractExpertRule.class)), false, true), + Arguments.of(Arrays.asList(mock(AbstractExpertRule.class), mock(AbstractExpertRule.class)), false, false) ); - - // When - Optional result = filterService.createOrCombination(rules); - - // Then - assertTrue(result.isPresent()); - assertInstanceOf(CombinatorExpertRule.class, result.get()); - - CombinatorExpertRule combinatorRule = (CombinatorExpertRule) result.get(); - assertEquals(CombinatorType.OR, combinatorRule.getCombinator()); } @Test void shouldReturnEmptyWhenCombineFilterResultsInputIsEmpty() { - // Given when(filterService.combineFilterResults(any(), anyBoolean())).thenCallRealMethod(); List> filterResults = Collections.emptyList(); - - // When List result = filterService.combineFilterResults(filterResults, true); - - // Then assertNotNull(result); assertTrue(result.isEmpty()); } @Test void shouldReturnIntersectionWhenUsingAndLogic() { - // Given when(filterService.combineFilterResults(any(), anyBoolean())).thenCallRealMethod(); List> filterResults = Arrays.asList( Arrays.asList("item1", "item2", "item3"), Arrays.asList("item2", "item3", "item4"), Arrays.asList("item2", "item5") ); - - // When List result = filterService.combineFilterResults(filterResults, true); - - // Then assertEquals(1, result.size()); assertTrue(result.contains("item2")); } @Test void shouldReturnUnionWhenUsingOrLogic() { - // Given when(filterService.combineFilterResults(any(), anyBoolean())).thenCallRealMethod(); List> filterResults = Arrays.asList( Arrays.asList("item1", "item2"), Arrays.asList("item3", "item4"), List.of("item5") ); - - // When List result = filterService.combineFilterResults(filterResults, false); - - // Then assertEquals(5, result.size()); assertTrue(result.containsAll(Arrays.asList("item1", "item2", "item3", "item4", "item5"))); } @Test void shouldReturnIdsFromFilteredNetwork() { - // Given when(filterService.filterNetwork(any(), any())).thenCallRealMethod(); AbstractFilter filter = mock(AbstractFilter.class); - try (MockedStatic mockStatic = mockStatic(FilterServiceUtils.class)) { List attributes = Arrays.asList( createIdentifiableAttributes("id1"), createIdentifiableAttributes("id2") ); - - mockStatic.when(() -> FilterServiceUtils.getIdentifiableAttributes(filter, network, filterService)) - .thenReturn(attributes); - - // When + mockStatic.when(() -> FilterServiceUtils.getIdentifiableAttributes(filter, network, filterService)).thenReturn(attributes); List result = filterService.filterNetwork(filter, network); - - // Then assertEquals(Arrays.asList("id1", "id2"), result); } } - @Test - void shouldCreateCorrectRuleForSideOne() { - // Given + @ParameterizedTest + @MethodSource("voltageLevelRuleData") + void shouldCreateVoltageLevelIdRule(TwoSides side, FieldType expectedFieldType) { when(filterService.createVoltageLevelIdRule(any(), any())).thenCallRealMethod(); UUID filterUuid = UUID.randomUUID(); - - // When - AbstractExpertRule result = filterService.createVoltageLevelIdRule(filterUuid, TwoSides.ONE); - - // Then + AbstractExpertRule result = filterService.createVoltageLevelIdRule(filterUuid, side); assertNotNull(result); assertInstanceOf(FilterUuidExpertRule.class, result); - FilterUuidExpertRule rule = (FilterUuidExpertRule) result; assertEquals(OperatorType.IS_PART_OF, rule.getOperator()); - assertEquals(FieldType.VOLTAGE_LEVEL_ID_1, rule.getField()); + assertEquals(expectedFieldType, rule.getField()); assertTrue(rule.getValues().contains(filterUuid.toString())); } - @Test - void shouldCreateCorrectRuleForSideTwo() { - // Given - when(filterService.createVoltageLevelIdRule(any(), any())).thenCallRealMethod(); - UUID filterUuid = UUID.randomUUID(); - - // When - AbstractExpertRule result = filterService.createVoltageLevelIdRule(filterUuid, TwoSides.TWO); - - // Then - assertNotNull(result); - assertInstanceOf(FilterUuidExpertRule.class, result); + private static Stream voltageLevelRuleData() { + return Stream.of( + Arguments.of(TwoSides.ONE, FieldType.VOLTAGE_LEVEL_ID_1), + Arguments.of(TwoSides.TWO, FieldType.VOLTAGE_LEVEL_ID_2) + ); + } - FilterUuidExpertRule rule = (FilterUuidExpertRule) result; - assertEquals(OperatorType.IS_PART_OF, rule.getOperator()); - assertEquals(FieldType.VOLTAGE_LEVEL_ID_2, rule.getField()); - assertTrue(rule.getValues().contains(filterUuid.toString())); + @ParameterizedTest + @MethodSource("fieldTypeData") + void shouldReturnCorrectFieldTypes(String category, EquipmentType equipmentType, List expectedFields) { + switch (category) { + case GlobalFilter.Fields.nominalV -> when(filterService.getNominalVoltageFieldType(any())).thenCallRealMethod(); + case GlobalFilter.Fields.countryCode -> when(filterService.getCountryCodeFieldType(any())).thenCallRealMethod(); + case GlobalFilter.Fields.substationProperty -> when(filterService.getSubstationPropertiesFieldTypes(any())).thenCallRealMethod(); + default -> throw new IllegalArgumentException("Unknown category: " + category); + } + List result = switch (category) { + case GlobalFilter.Fields.nominalV -> filterService.getNominalVoltageFieldType(equipmentType); + case GlobalFilter.Fields.countryCode -> filterService.getCountryCodeFieldType(equipmentType); + case GlobalFilter.Fields.substationProperty -> filterService.getSubstationPropertiesFieldTypes(equipmentType); + default -> Collections.emptyList(); + }; + assertEquals(expectedFields, result); + } + + private static Stream fieldTypeData() { + return Stream.of( + // Nominal voltage + Arguments.of(GlobalFilter.Fields.nominalV, EquipmentType.LINE, List.of(FieldType.NOMINAL_VOLTAGE_1, FieldType.NOMINAL_VOLTAGE_2)), + Arguments.of(GlobalFilter.Fields.nominalV, EquipmentType.TWO_WINDINGS_TRANSFORMER, List.of(FieldType.NOMINAL_VOLTAGE_1, FieldType.NOMINAL_VOLTAGE_2)), + Arguments.of(GlobalFilter.Fields.nominalV, EquipmentType.VOLTAGE_LEVEL, List.of(FieldType.NOMINAL_VOLTAGE)), + Arguments.of(GlobalFilter.Fields.nominalV, EquipmentType.GENERATOR, Collections.emptyList()), + + // Country code + Arguments.of(GlobalFilter.Fields.countryCode, EquipmentType.VOLTAGE_LEVEL, List.of(FieldType.COUNTRY)), + Arguments.of(GlobalFilter.Fields.countryCode, EquipmentType.TWO_WINDINGS_TRANSFORMER, List.of(FieldType.COUNTRY)), + Arguments.of(GlobalFilter.Fields.countryCode, EquipmentType.LINE, List.of(FieldType.COUNTRY_1, FieldType.COUNTRY_2)), + Arguments.of(GlobalFilter.Fields.countryCode, EquipmentType.GENERATOR, Collections.emptyList()), + + // Substation properties + Arguments.of(GlobalFilter.Fields.substationProperty, EquipmentType.LINE, List.of(FieldType.SUBSTATION_PROPERTIES_1, FieldType.SUBSTATION_PROPERTIES_2)), + Arguments.of(GlobalFilter.Fields.substationProperty, EquipmentType.GENERATOR, List.of(FieldType.SUBSTATION_PROPERTIES)) + ); } @Test void shouldReturnEmptyWhenNoExpertFiltersProvided() { - // Given when(filterService.buildAllExpertRules(any(), any())).thenCallRealMethod(); when(filterService.buildNominalVoltageRules(any(), any())).thenCallRealMethod(); - GlobalFilter globalFilter = mock(GlobalFilter.class); when(globalFilter.getNominalV()).thenReturn(null); when(globalFilter.getCountryCode()).thenReturn(null); when(globalFilter.getSubstationProperty()).thenReturn(null); - - // When List result = filterService.buildAllExpertRules(globalFilter, EquipmentType.GENERATOR); - - // Then assertNotNull(result); assertTrue(result.isEmpty()); } @Test void shouldReturnRulesWhenFilterExpertRulesProvided() { - // Given when(filterService.buildAllExpertRules(any(), any())).thenCallRealMethod(); when(filterService.buildNominalVoltageRules(any(), any())).thenCallRealMethod(); when(filterService.buildCountryCodeRules(any(), any())).thenCallRealMethod(); @@ -489,125 +386,30 @@ void shouldReturnRulesWhenFilterExpertRulesProvided() { when(filterService.createEnumExpertRules(any(), any())).thenCallRealMethod(); when(filterService.createPropertiesRule(any(), any(), any())).thenCallRealMethod(); when(filterService.createOrCombination(any())).thenCallRealMethod(); - GlobalFilter globalFilter = mock(GlobalFilter.class); when(globalFilter.getNominalV()).thenReturn(List.of("400.0")); when(globalFilter.getCountryCode()).thenReturn(List.of(Country.FR)); when(globalFilter.getSubstationProperty()).thenReturn(Map.of("prop1", List.of("value1"))); - - // When List result = filterService.buildAllExpertRules(globalFilter, EquipmentType.GENERATOR); - - // Then assertNotNull(result); assertEquals(3, result.size()); } - @Test - void shouldReturnEmptyWhenNoNominalVoltageRules() { - // Given - when(filterService.buildNominalVoltageRules(any(), any())).thenCallRealMethod(); - when(filterService.getNominalVoltageFieldType(any())).thenReturn(List.of(FieldType.NOMINAL_VOLTAGE)); - - // When - Optional result = filterService.buildNominalVoltageRules(null, EquipmentType.GENERATOR); - - // Then - assertFalse(result.isPresent()); - } - - @Test - void shouldCreateRulesWhenNominalVoltageRulesProvided() { - // Given - when(filterService.buildNominalVoltageRules(any(), any())).thenCallRealMethod(); - when(filterService.getNominalVoltageFieldType(any())).thenReturn(List.of(FieldType.NOMINAL_VOLTAGE)); - when(filterService.createNumberExpertRules(any(), any())).thenCallRealMethod(); - when(filterService.createOrCombination(any())).thenCallRealMethod(); - when(filterService.createCombination(any(), any())).thenCallRealMethod(); - - List voltages = Arrays.asList("400.0", "225.0"); - - // When - Optional result = filterService.buildNominalVoltageRules(voltages, EquipmentType.GENERATOR); - - // Then - assertTrue(result.isPresent()); - } - - @Test - void shouldReturnEmptyWhenNoCountriesCodeRules() { - // Given - when(filterService.buildCountryCodeRules(any(), any())).thenCallRealMethod(); - when(filterService.getCountryCodeFieldType(any())).thenReturn(List.of(FieldType.COUNTRY)); - - // When - Optional result = filterService.buildCountryCodeRules(null, EquipmentType.GENERATOR); - - // Then - assertFalse(result.isPresent()); - } - - @Test - void shouldCreateRulesWhenCountriesCountryCodeRulesProvided() { - // Given - when(filterService.buildCountryCodeRules(any(), any())).thenCallRealMethod(); - when(filterService.getCountryCodeFieldType(any())).thenReturn(List.of(FieldType.COUNTRY)); - when(filterService.createEnumExpertRules(any(), any())).thenCallRealMethod(); - when(filterService.createOrCombination(any())).thenCallRealMethod(); - when(filterService.createCombination(any(), any())).thenCallRealMethod(); - - List countries = Arrays.asList(Country.FR, Country.DE); - - // When - Optional result = filterService.buildCountryCodeRules(countries, EquipmentType.GENERATOR); - - // Then - assertTrue(result.isPresent()); - } - - @Test - void shouldCreateRulesWhenSubstationPropertiesProvided() { - // Given - when(filterService.buildSubstationPropertyRules(any(), any())).thenCallRealMethod(); - when(filterService.getSubstationPropertiesFieldTypes(any())).thenReturn(List.of(FieldType.SUBSTATION_PROPERTIES)); - when(filterService.createPropertiesRule(any(), any(), any())).thenCallRealMethod(); - when(filterService.createOrCombination(any())).thenCallRealMethod(); - when(filterService.createCombination(any(), any())).thenCallRealMethod(); - - Map> properties = Map.of( - "prop1", Arrays.asList("value1", "value2"), - "prop2", List.of("value3") - ); - - // When - Optional result = filterService.buildSubstationPropertyRules(properties, EquipmentType.GENERATOR); - - // Then - assertTrue(result.isPresent()); - } - @Test void shouldReturnNullWhenNoRules() { - // Given when(filterService.buildExpertFilter(any(), any())).thenCallRealMethod(); when(filterService.buildAllExpertRules(any(), any())).thenCallRealMethod(); when(filterService.buildNominalVoltageRules(any(), any())).thenCallRealMethod(); - GlobalFilter globalFilter = mock(GlobalFilter.class); when(globalFilter.getNominalV()).thenReturn(null); when(globalFilter.getCountryCode()).thenReturn(null); when(globalFilter.getSubstationProperty()).thenReturn(null); - - // When ExpertFilter result = filterService.buildExpertFilter(globalFilter, EquipmentType.GENERATOR); - - // Then assertNull(result); } @Test void shouldCreateFilterWhenRulesExist() { - // Given when(filterService.buildExpertFilter(any(), any())).thenCallRealMethod(); when(filterService.buildAllExpertRules(any(), any())).thenCallRealMethod(); when(filterService.buildNominalVoltageRules(any(), any())).thenCallRealMethod(); @@ -615,16 +417,11 @@ void shouldCreateFilterWhenRulesExist() { when(filterService.getNominalVoltageFieldType(any())).thenReturn(List.of(FieldType.NOMINAL_VOLTAGE)); when(filterService.createNumberExpertRules(any(), any())).thenCallRealMethod(); when(filterService.createOrCombination(any())).thenCallRealMethod(); - GlobalFilter globalFilter = mock(GlobalFilter.class); when(globalFilter.getNominalV()).thenReturn(List.of("400.0")); when(globalFilter.getCountryCode()).thenReturn(null); when(globalFilter.getSubstationProperty()).thenReturn(null); - - // When ExpertFilter result = filterService.buildExpertFilter(globalFilter, EquipmentType.GENERATOR); - - // Then assertNotNull(result); assertEquals(EquipmentType.GENERATOR, result.getEquipmentType()); assertNotNull(result.getRules()); @@ -633,509 +430,104 @@ void shouldCreateFilterWhenRulesExist() { @Test void shouldReturnFilteredNetworkWhenSameEquipmentType() { - // Given when(filterService.extractEquipmentIdsFromGenericFilter(any(), any(), any())).thenCallRealMethod(); when(filterService.filterNetwork(any(), any())).thenCallRealMethod(); - AbstractFilter filter = mock(AbstractFilter.class); when(filter.getEquipmentType()).thenReturn(EquipmentType.GENERATOR); - try (MockedStatic mockStatic = mockStatic(FilterServiceUtils.class)) { List attributes = Arrays.asList( createIdentifiableAttributes("gen1"), createIdentifiableAttributes("gen2") ); - mockStatic.when(() -> FilterServiceUtils.getIdentifiableAttributes(filter, network, filterService)) - .thenReturn(attributes); - - // When - List result = filterService.extractEquipmentIdsFromGenericFilter( - filter, EquipmentType.GENERATOR, network); - - // Then + mockStatic.when(() -> FilterServiceUtils.getIdentifiableAttributes(filter, network, filterService)).thenReturn(attributes); + List result = filterService.extractEquipmentIdsFromGenericFilter(filter, EquipmentType.GENERATOR, network); assertEquals(Arrays.asList("gen1", "gen2"), result); } } @Test void shouldBuildVoltageLevelFilterWhenVoltageLevelType() { - // Given when(filterService.extractEquipmentIdsFromGenericFilter(any(), any(), any())).thenCallRealMethod(); when(filterService.buildExpertFilterWithVoltageLevelIdsCriteria(any(), any())).thenCallRealMethod(); when(filterService.createVoltageLevelIdRule(any(), any())).thenCallRealMethod(); when(filterService.createCombination(any(), any())).thenCallRealMethod(); when(filterService.filterNetwork(any(), any())).thenCallRealMethod(); - AbstractFilter filter = mock(AbstractFilter.class); when(filter.getEquipmentType()).thenReturn(EquipmentType.VOLTAGE_LEVEL); when(filter.getId()).thenReturn(FILTER_UUID); - try (MockedStatic mockStatic = mockStatic(FilterServiceUtils.class)) { List attributes = Arrays.asList( createIdentifiableAttributes("line1"), createIdentifiableAttributes("line2") ); - mockStatic.when(() -> FilterServiceUtils.getIdentifiableAttributes(any(ExpertFilter.class), eq(network), eq(filterService))) - .thenReturn(attributes); - - // When - List result = filterService.extractEquipmentIdsFromGenericFilter( - filter, EquipmentType.LINE, network); - - // Then + mockStatic.when(() -> FilterServiceUtils.getIdentifiableAttributes(any(ExpertFilter.class), eq(network), eq(filterService))).thenReturn(attributes); + List result = filterService.extractEquipmentIdsFromGenericFilter(filter, EquipmentType.LINE, network); assertEquals(Arrays.asList("line1", "line2"), result); } } @Test void shouldReturnEmptyWhenDifferentEquipmentType() { - // Given when(filterService.extractEquipmentIdsFromGenericFilter(any(), any(), any())).thenCallRealMethod(); - AbstractFilter filter = mock(AbstractFilter.class); when(filter.getEquipmentType()).thenReturn(EquipmentType.LOAD); - - // When - List result = filterService.extractEquipmentIdsFromGenericFilter( - filter, EquipmentType.GENERATOR, network); - - // Then + List result = filterService.extractEquipmentIdsFromGenericFilter(filter, EquipmentType.GENERATOR, network); assertTrue(result.isEmpty()); } @Test void shouldCreateExpertFilterWithVoltageLevelIdsCriteria() { - // Given when(filterService.buildExpertFilterWithVoltageLevelIdsCriteria(any(), any())).thenCallRealMethod(); when(filterService.createVoltageLevelIdRule(any(), any())).thenCallRealMethod(); when(filterService.createCombination(any(), any())).thenCallRealMethod(); - UUID filterUuid = UUID.randomUUID(); EquipmentType equipmentType = EquipmentType.LINE; - - // When ExpertFilter result = filterService.buildExpertFilterWithVoltageLevelIdsCriteria(filterUuid, equipmentType); - - // Then assertNotNull(result); assertEquals(equipmentType, result.getEquipmentType()); assertNotNull(result.getRules()); assertInstanceOf(CombinatorExpertRule.class, result.getRules()); - CombinatorExpertRule combinatorRule = (CombinatorExpertRule) result.getRules(); assertEquals(CombinatorType.OR, combinatorRule.getCombinator()); assertEquals(2, combinatorRule.getRules().size()); } @Test - void testGetNominalVoltageFieldType() { - // Given - when(filterService.getNominalVoltageFieldType(any())).thenCallRealMethod(); - - // When - List result = filterService.getNominalVoltageFieldType(EquipmentType.LINE); - - // Then - assertNotNull(result); - assertEquals(2, result.size()); - assertEquals(FieldType.NOMINAL_VOLTAGE_1, result.get(0)); - assertEquals(FieldType.NOMINAL_VOLTAGE_2, result.get(1)); - } - - @Test - void testGetCountryCodeField() { - // Given - when(filterService.getCountryCodeFieldType(any())).thenCallRealMethod(); - - // When - List result = filterService.getCountryCodeFieldType(EquipmentType.LINE); - - // Then - assertNotNull(result); - assertEquals(2, result.size()); - assertEquals(FieldType.COUNTRY_1, result.get(0)); - assertEquals(FieldType.COUNTRY_2, result.get(1)); - } - - @Test - void testGetSubstationPropertiesFieldTypes() { - // Given - when(filterService.getSubstationPropertiesFieldTypes(any())).thenCallRealMethod(); - - // When - List result = filterService.getSubstationPropertiesFieldTypes(EquipmentType.LINE); - - // Then - assertNotNull(result); - assertEquals(2, result.size()); - assertEquals(FieldType.SUBSTATION_PROPERTIES_1, result.get(0)); - assertEquals(FieldType.SUBSTATION_PROPERTIES_2, result.get(1)); - } - - @Test - void testGetSubstationPropertiesFieldTypesWithNonLineEquipmentTypes() { - // Given - when(filterService.getSubstationPropertiesFieldTypes(any())).thenCallRealMethod(); - - // Test various non-LINE equipment types that should return single SUBSTATION_PROPERTIES - EquipmentType[] nonLineTypes = { - EquipmentType.VOLTAGE_LEVEL, EquipmentType.TWO_WINDINGS_TRANSFORMER, EquipmentType.GENERATOR, - EquipmentType.LOAD, EquipmentType.SHUNT_COMPENSATOR, EquipmentType.STATIC_VAR_COMPENSATOR, - EquipmentType.BATTERY, EquipmentType.BUSBAR_SECTION, EquipmentType.LCC_CONVERTER_STATION, - EquipmentType.VSC_CONVERTER_STATION, EquipmentType.SUBSTATION, EquipmentType.THREE_WINDINGS_TRANSFORMER - }; - - for (EquipmentType equipmentType : nonLineTypes) { - // When - List result = filterService.getSubstationPropertiesFieldTypes(equipmentType); - - // Then - assertNotNull(result, "Result should not be null for " + equipmentType); - assertEquals(1, result.size(), "Result should have size 1 for " + equipmentType); - assertEquals(FieldType.SUBSTATION_PROPERTIES, result.getFirst(), "Should return SUBSTATION_PROPERTIES for " + equipmentType); - assertTrue(result.contains(FieldType.SUBSTATION_PROPERTIES), "Should contain SUBSTATION_PROPERTIES for " + equipmentType); - } - } - - // Tests for filterEquipmentsByType - @Test - void testFilterEquipmentsByTypeWithEmptyEquipmentTypes() { - // Given - when(filterService.filterEquipmentsByType(any(), any(), any(), any())).thenCallRealMethod(); - GlobalFilter globalFilter = mock(GlobalFilter.class); - List genericFilters = Collections.emptyList(); - List equipmentTypes = Collections.emptyList(); - - // When - Map> result = filterService.filterEquipmentsByType( - network, globalFilter, genericFilters, equipmentTypes); - - // Then - assertNotNull(result); - assertTrue(result.isEmpty()); - assertInstanceOf(EnumMap.class, result); - } - - @Test - void testFilterEquipmentsByTypeWithEquipmentTypes() { - // Given - when(filterService.filterEquipmentsByType(any(), any(), any(), any())).thenCallRealMethod(); - when(filterService.extractFilteredEquipmentIds(any(), any(), any(), any())).thenReturn(Arrays.asList("line1", "line2")); - - GlobalFilter globalFilter = mock(GlobalFilter.class); - List genericFilters = Collections.emptyList(); - List equipmentTypes = Arrays.asList(EquipmentType.LINE, EquipmentType.GENERATOR); - - // When - Map> result = filterService.filterEquipmentsByType( - network, globalFilter, genericFilters, equipmentTypes); - - // Then - assertNotNull(result); - assertInstanceOf(EnumMap.class, result); - assertEquals(2, result.size()); - assertTrue(result.containsKey(EquipmentType.LINE)); - assertTrue(result.containsKey(EquipmentType.GENERATOR)); - assertEquals(Arrays.asList("line1", "line2"), result.get(EquipmentType.LINE)); - assertEquals(Arrays.asList("line1", "line2"), result.get(EquipmentType.GENERATOR)); - } - - @Test - void testFilterEquipmentsByTypeWithEmptyFilterResults() { - // Given - when(filterService.filterEquipmentsByType(any(), any(), any(), any())).thenCallRealMethod(); - when(filterService.extractFilteredEquipmentIds(any(), any(), any(), any())).thenReturn(Collections.emptyList()); - - GlobalFilter globalFilter = mock(GlobalFilter.class); - List genericFilters = Collections.emptyList(); - List equipmentTypes = List.of(EquipmentType.LINE); - - // When - Map> result = filterService.filterEquipmentsByType( - network, globalFilter, genericFilters, equipmentTypes); - - // Then - assertNotNull(result); - assertTrue(result.isEmpty()); - } - - @Test - void testFilterEquipmentsByTypeWithMixedResults() { - // Given - when(filterService.filterEquipmentsByType(any(), any(), any(), any())).thenCallRealMethod(); - when(filterService.extractFilteredEquipmentIds(any(), any(), any(), eq(EquipmentType.LINE))) - .thenReturn(Arrays.asList("line1", "line2")); - when(filterService.extractFilteredEquipmentIds(any(), any(), any(), eq(EquipmentType.GENERATOR))) - .thenReturn(Collections.emptyList()); - when(filterService.extractFilteredEquipmentIds(any(), any(), any(), eq(EquipmentType.LOAD))) - .thenReturn(List.of("load1")); - - GlobalFilter globalFilter = mock(GlobalFilter.class); - List genericFilters = Collections.emptyList(); - List equipmentTypes = Arrays.asList(EquipmentType.LINE, EquipmentType.GENERATOR, EquipmentType.LOAD); - - // When - Map> result = filterService.filterEquipmentsByType( - network, globalFilter, genericFilters, equipmentTypes); - - // Then - assertNotNull(result); - assertEquals(2, result.size()); // Only LINE and LOAD should be present (not GENERATOR with empty results) - assertTrue(result.containsKey(EquipmentType.LINE)); - assertTrue(result.containsKey(EquipmentType.LOAD)); - assertFalse(result.containsKey(EquipmentType.GENERATOR)); - assertEquals(Arrays.asList("line1", "line2"), result.get(EquipmentType.LINE)); - assertEquals(List.of("load1"), result.get(EquipmentType.LOAD)); - } - - // Tests for extractFilteredEquipmentIds - @Test - void testExtractFilteredEquipmentIdsWithEmptyFilters() { - // Given - when(filterService.extractFilteredEquipmentIds(any(), any(), any(), any())).thenCallRealMethod(); - when(filterService.buildExpertFilter(any(), any())).thenReturn(null); - when(filterService.combineFilterResults(any(), anyBoolean())).thenCallRealMethod(); - - GlobalFilter globalFilter = mock(GlobalFilter.class); - List genericFilters = Collections.emptyList(); - - // When - List result = filterService.extractFilteredEquipmentIds( - network, globalFilter, genericFilters, EquipmentType.LINE); - - // Then - assertNotNull(result); - assertTrue(result.isEmpty()); - } - - @Test - void testExtractFilteredEquipmentIdsWithExpertFilter() { - // Given - when(filterService.extractFilteredEquipmentIds(any(), any(), any(), any())).thenCallRealMethod(); - when(filterService.buildExpertFilter(any(), any())).thenReturn(mock(ExpertFilter.class)); - when(filterService.filterNetwork(any(), any())).thenReturn(Arrays.asList("line1", "line2")); - when(filterService.combineFilterResults(any(), anyBoolean())).thenCallRealMethod(); - - GlobalFilter globalFilter = mock(GlobalFilter.class); - List genericFilters = Collections.emptyList(); - - // When - List result = filterService.extractFilteredEquipmentIds( - network, globalFilter, genericFilters, EquipmentType.LINE); - - // Then - assertNotNull(result); - assertEquals(Arrays.asList("line1", "line2"), result); - } - - @Test - void testExtractFilteredEquipmentIdsWithGenericFilters() { - // Given - when(filterService.extractFilteredEquipmentIds(any(), any(), any(), any())).thenCallRealMethod(); - when(filterService.buildExpertFilter(any(), any())).thenReturn(null); - when(filterService.extractEquipmentIdsFromGenericFilter(any(), any(), any())) - .thenReturn(Arrays.asList("line3", "line4")); - when(filterService.combineFilterResults(any(), anyBoolean())).thenCallRealMethod(); - - GlobalFilter globalFilter = mock(GlobalFilter.class); - AbstractFilter genericFilter = mock(AbstractFilter.class); - List genericFilters = Collections.singletonList(genericFilter); - - // When - List result = filterService.extractFilteredEquipmentIds( - network, globalFilter, genericFilters, EquipmentType.LINE); - - // Then - assertNotNull(result); - assertEquals(Arrays.asList("line3", "line4"), result); - } - - @Test - void testExtractFilteredEquipmentIdsWithBothFilters() { - // Given - when(filterService.extractFilteredEquipmentIds(any(), any(), any(), any())).thenCallRealMethod(); - when(filterService.buildExpertFilter(any(), any())).thenReturn(mock(ExpertFilter.class)); - when(filterService.filterNetwork(any(), any())).thenReturn(Arrays.asList("line1", "line2")); - when(filterService.extractEquipmentIdsFromGenericFilter(any(), any(), any())) - .thenReturn(Arrays.asList("line2", "line3")); - when(filterService.combineFilterResults(any(), anyBoolean())).thenCallRealMethod(); - - GlobalFilter globalFilter = mock(GlobalFilter.class); - AbstractFilter genericFilter = mock(AbstractFilter.class); - List genericFilters = Collections.singletonList(genericFilter); - - // When - List result = filterService.extractFilteredEquipmentIds( - network, globalFilter, genericFilters, EquipmentType.LINE); - - // Then - assertNotNull(result); - assertEquals(List.of("line2"), result); // Intersection of both filter results - } - - @Test - void testExtractFilteredEquipmentIdsWithMultipleGenericFilters() { - AbstractFilter genericFilter1 = mock(AbstractFilter.class); - AbstractFilter genericFilter2 = mock(AbstractFilter.class); - GlobalFilter globalFilter = mock(GlobalFilter.class); - // Given - when(filterService.extractFilteredEquipmentIds(any(), any(), any(), any())).thenCallRealMethod(); - when(filterService.buildExpertFilter(any(), any())).thenReturn(null); - when(filterService.extractEquipmentIdsFromGenericFilter(eq(genericFilter1), any(), any())) - .thenReturn(Arrays.asList("line1", "line2")); - when(filterService.extractEquipmentIdsFromGenericFilter(eq(genericFilter2), any(), any())) - .thenReturn(Arrays.asList("line2", "line3")); - when(filterService.combineFilterResults(any(), anyBoolean())).thenCallRealMethod(); - - List genericFilters = Arrays.asList(genericFilter1, genericFilter2); - - // When - List result = filterService.extractFilteredEquipmentIds( - network, globalFilter, genericFilters, EquipmentType.LINE); - - // Then - assertNotNull(result); - assertEquals(List.of("line2"), result); // AND logic for generic filters - } - - // Tests for getResourceFilter - @Test - void testGetResourceFilterWithEmptyResults() { - // Given + void shouldReturnEmptyWhenNoFilterResults() { when(filterService.getResourceFilter(any(), any(), any(), any(), any())).thenCallRealMethod(); when(filterService.getNetwork(any(), any())).thenReturn(network); when(filterService.getFilters(any())).thenReturn(Collections.emptyList()); - when(filterService.filterEquipmentsByType(any(), any(), any(), any())) - .thenReturn(Collections.emptyMap()); - + when(filterService.filterEquipmentsByType(any(), any(), any(), any())).thenReturn(Collections.emptyMap()); GlobalFilter globalFilter = mock(GlobalFilter.class); when(globalFilter.getGenericFilter()).thenReturn(Collections.emptyList()); List equipmentTypes = List.of(EquipmentType.LINE); String columnName = "functionId"; - - // When Optional result = filterService.getResourceFilter(NETWORK_UUID, VARIANT_ID, globalFilter, equipmentTypes, columnName); - - // Then assertNotNull(result); assertFalse(result.isPresent()); } @Test - void testGetResourceFilterWithResults() { - // Given + void shouldReturnResourceFilterWithResults() { when(filterService.getResourceFilter(any(), any(), any(), any(), any())).thenCallRealMethod(); when(filterService.getNetwork(any(), any())).thenReturn(network); when(filterService.getFilters(any())).thenReturn(Collections.emptyList()); - Map> equipmentResults = new EnumMap<>(EquipmentType.class); equipmentResults.put(EquipmentType.LINE, Arrays.asList("line1", "line2")); equipmentResults.put(EquipmentType.GENERATOR, List.of("gen1")); when(filterService.filterEquipmentsByType(any(), any(), any(), any())).thenReturn(equipmentResults); - GlobalFilter globalFilter = mock(GlobalFilter.class); when(globalFilter.getGenericFilter()).thenReturn(Collections.emptyList()); List equipmentTypes = Arrays.asList(EquipmentType.LINE, EquipmentType.GENERATOR); String columnName = "functionId"; - - // When - Optional result = filterService.getResourceFilter( - NETWORK_UUID, VARIANT_ID, globalFilter, equipmentTypes, columnName); - - // Then + Optional result = filterService.getResourceFilter(NETWORK_UUID, VARIANT_ID, globalFilter, equipmentTypes, columnName); assertNotNull(result); assertTrue(result.isPresent()); - ResourceFilterDTO dto = result.get(); assertEquals(ResourceFilterDTO.DataType.TEXT, dto.dataType()); assertEquals(ResourceFilterDTO.Type.IN, dto.type()); assertEquals(columnName, dto.column()); - assertEquals(dto.value(), List.of("line1", "line2", "gen1")); - } - - @Test - void testGetResourceFilterWithNullValues() { - // Given - when(filterService.getResourceFilter(any(), any(), any(), any(), any())).thenCallRealMethod(); - when(filterService.getNetwork(any(), any())).thenReturn(network); - when(filterService.getFilters(any())).thenReturn(Collections.emptyList()); - - Map> equipmentResults = new EnumMap<>(EquipmentType.class); - equipmentResults.put(EquipmentType.LINE, Arrays.asList("line1", "line2")); - equipmentResults.put(EquipmentType.GENERATOR, null); // null value should be filtered out - when(filterService.filterEquipmentsByType(any(), any(), any(), any())).thenReturn(equipmentResults); - - GlobalFilter globalFilter = mock(GlobalFilter.class); - when(globalFilter.getGenericFilter()).thenReturn(Collections.emptyList()); - List equipmentTypes = Arrays.asList(EquipmentType.LINE, EquipmentType.GENERATOR); - String columnName = "functionId"; - - // When - Optional result = filterService.getResourceFilter( - NETWORK_UUID, VARIANT_ID, globalFilter, equipmentTypes, columnName); - - // Then - assertNotNull(result); - assertTrue(result.isPresent()); - - ResourceFilterDTO dto = result.get(); - assertEquals(dto.value(), List.of("line1", "line2")); // Only line1, line2 (null values filtered out) - } - - @Test - void testGetResourceFilterWithGenericFilters() { - // Given - when(filterService.getResourceFilter(any(), any(), any(), any(), any())).thenCallRealMethod(); - when(filterService.getNetwork(any(), any())).thenReturn(network); - - AbstractFilter genericFilter = mock(AbstractFilter.class); - List genericFilters = Collections.singletonList(genericFilter); - when(filterService.getFilters(any())).thenReturn(genericFilters); - - Map> equipmentResults = new EnumMap<>(EquipmentType.class); - equipmentResults.put(EquipmentType.LINE, List.of("line1")); - when(filterService.filterEquipmentsByType(any(), any(), any(), any())).thenReturn(equipmentResults); - - GlobalFilter globalFilter = mock(GlobalFilter.class); - List filterUuids = List.of(UUID.randomUUID()); - when(globalFilter.getGenericFilter()).thenReturn(filterUuids); - List equipmentTypes = List.of(EquipmentType.LINE); - String columnName = "functionId"; - - // When - Optional result = filterService.getResourceFilter( - NETWORK_UUID, VARIANT_ID, globalFilter, equipmentTypes, columnName); - - // Then - assertNotNull(result); - assertTrue(result.isPresent()); - verify(filterService).getFilters(filterUuids); - } - - @Test - void testGetResourceFilterCustomColumnName() { - // Given - when(filterService.getResourceFilter(any(), any(), any(), any(), any())).thenCallRealMethod(); - when(filterService.getNetwork(any(), any())).thenReturn(network); - when(filterService.getFilters(any())).thenReturn(Collections.emptyList()); - - Map> equipmentResults = new EnumMap<>(EquipmentType.class); - equipmentResults.put(EquipmentType.LINE, List.of("line1")); - when(filterService.filterEquipmentsByType(any(), any(), any(), any())).thenReturn(equipmentResults); - - GlobalFilter globalFilter = mock(GlobalFilter.class); - when(globalFilter.getGenericFilter()).thenReturn(Collections.emptyList()); - List equipmentTypes = List.of(EquipmentType.LINE); - String customColumnName = "customColumn"; - - // When - Optional result = filterService.getResourceFilter( - NETWORK_UUID, VARIANT_ID, globalFilter, equipmentTypes, customColumnName); - - // Then - assertNotNull(result); - assertTrue(result.isPresent()); - assertEquals(customColumnName, result.get().column()); + assertEquals(3, ((List) dto.value()).size()); } private IdentifiableAttributes createIdentifiableAttributes(String id) {