Update filter on EA + better tests coverage

Signed-off-by: Thomas Bouquet <thomas.bouquet@rte-france.com>

data/crac/crac-api/pom.xml

@@ -48,11 +48,5 @@
             <groupId>com.powsybl</groupId>
             <artifactId>powsybl-contingency-api</artifactId>
         </dependency>
-        <dependency>
-            <groupId>org.mockito</groupId>
-            <artifactId>mockito-core</artifactId>
-            <version>5.2.0</version>
-            <scope>test</scope>
-        </dependency>
     </dependencies>
 </project>

data/crac/crac-api/src/main/java/com/powsybl/openrao/data/cracapi/networkaction/InjectionSetpoint.java

@@ -31,4 +31,12 @@ public interface InjectionSetpoint extends ElementaryAction {
      * Get the unit of the injection setpoint
      */
     Unit getUnit();
+
+    @Override
+    default boolean isCompatibleWith(ElementaryAction otherElementaryAction) {
+        if (otherElementaryAction instanceof InjectionSetpoint injectionSetpoint) {
+            return !getNetworkElement().equals(injectionSetpoint.getNetworkElement()) || getSetpoint() == injectionSetpoint.getSetpoint() && getUnit() == injectionSetpoint.getUnit();
+        }
+        return true;
+    }
 }

data/crac/crac-api/src/main/java/com/powsybl/openrao/data/cracapi/networkaction/NetworkAction.java

@@ -14,7 +14,7 @@
 
 /**
  * Remedial action interface specifying a direct action on the network.
- *
+ * <p>
  * The Network Action is completely defined by itself.
  * It involves a Set of {@link ElementaryAction}.
  * When the apply method is called, an action is triggered on each of these Elementary
@@ -35,6 +35,7 @@ public interface NetworkAction extends RemedialAction<NetworkAction> {
 
     /**
      * Apply the action on a given network.
+     *
      * @param network the Network to apply the network action upon
      * @return true if the network action was applied, false if not (eg if it was already applied)
      */
@@ -47,6 +48,7 @@ public interface NetworkAction extends RemedialAction<NetworkAction> {
 
     /**
      * States if the network action can be applied without infringing on another network action's scope.
+     *
      * @param otherNetworkAction the other network action to check compatibility with
      * @return true if both network actions can be applied without any conflictual behaviour
      */

data/crac/crac-api/src/main/java/com/powsybl/openrao/data/cracapi/networkaction/PstSetpoint.java

@@ -25,4 +25,12 @@ public interface PstSetpoint extends ElementaryAction {
      * Get the Network Element associated to the elementary action
      */
     NetworkElement getNetworkElement();
+
+    @Override
+    default boolean isCompatibleWith(ElementaryAction otherElementaryAction) {
+        if (otherElementaryAction instanceof PstSetpoint pstSetpoint) {
+            return !getNetworkElement().equals(pstSetpoint.getNetworkElement()) || getSetpoint() == pstSetpoint.getSetpoint();
+        }
+        return true;
+    }
 }

data/crac/crac-api/src/main/java/com/powsybl/openrao/data/cracapi/networkaction/SwitchPair.java

@@ -19,10 +19,19 @@ public interface SwitchPair extends ElementaryAction {
     /**
      * Get the switch that should be opened by the elementary action
      */
-    public NetworkElement getSwitchToOpen();
+    NetworkElement getSwitchToOpen();
 
     /**
      * Get the switch that should be closed by the elementary action
      */
-    public NetworkElement getSwitchToClose();
+    NetworkElement getSwitchToClose();
+
+    @Override
+    default boolean isCompatibleWith(ElementaryAction otherElementaryAction) {
+        if (otherElementaryAction instanceof SwitchPair switchPair) {
+            return getSwitchToOpen().equals(switchPair.getSwitchToOpen()) && getSwitchToClose().equals(switchPair.getSwitchToClose())
+                || !getSwitchToOpen().equals(switchPair.getSwitchToOpen()) && !getSwitchToOpen().equals(switchPair.getSwitchToClose()) && !getSwitchToClose().equals(switchPair.getSwitchToClose()) && !getSwitchToClose().equals(switchPair.getSwitchToOpen());
+        }
+        return true;
+    }
 }

data/crac/crac-api/src/main/java/com/powsybl/openrao/data/cracapi/networkaction/TopologicalAction.java

@@ -25,4 +25,12 @@ public interface TopologicalAction extends ElementaryAction {
      * Get the Network Element associated to the elementary action
      */
     NetworkElement getNetworkElement();
+
+    @Override
+    default boolean isCompatibleWith(ElementaryAction otherElementaryAction) {
+        if (otherElementaryAction instanceof TopologicalAction topologicalAction) {
+            return !getNetworkElement().equals(topologicalAction.getNetworkElement()) || getActionType().equals(topologicalAction.getActionType());
+        }
+        return true;
+    }
 }

data/crac/crac-api/src/test/java/com/powsybl/openrao/data/cracapi/ElementaryActionCompatibilityTest.java

@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2024, RTE (http://www.rte-france.com)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+package com.powsybl.openrao.data.cracapi;
+
+import com.powsybl.openrao.commons.Unit;
+import com.powsybl.openrao.data.cracapi.networkaction.ActionType;
+import com.powsybl.openrao.data.cracapi.networkaction.ElementaryAction;
+import com.powsybl.openrao.data.cracapi.networkaction.InjectionSetpoint;
+import com.powsybl.openrao.data.cracapi.networkaction.PstSetpoint;
+import com.powsybl.openrao.data.cracapi.networkaction.SwitchPair;
+import com.powsybl.openrao.data.cracapi.networkaction.TopologicalAction;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * @author Thomas Bouquet {@literal <thomas.bouquet at rte-france.com>}
+ */
+class ElementaryActionCompatibilityTest {
+    private final NetworkElement switchFr = NetworkActionUtils.createNetworkElement("switch-fr");
+    private final NetworkElement switchBe = NetworkActionUtils.createNetworkElement("switch-be");
+    private final NetworkElement pstFr = NetworkActionUtils.createNetworkElement("pst-fr");
+    private final NetworkElement pstBe = NetworkActionUtils.createNetworkElement("pst-be");
+    private final NetworkElement generatorFr = NetworkActionUtils.createNetworkElement("generator-fr");
+    private final NetworkElement generatorBe = NetworkActionUtils.createNetworkElement("generator-be");
+    private final TopologicalAction openSwitchFr = NetworkActionUtils.createTopologyAction(switchFr, ActionType.OPEN);
+    private final TopologicalAction closeSwitchFr = NetworkActionUtils.createTopologyAction(switchFr, ActionType.CLOSE);
+    private final TopologicalAction openSwitchBe = NetworkActionUtils.createTopologyAction(switchBe, ActionType.OPEN);
+    private final TopologicalAction closeSwitchBe = NetworkActionUtils.createTopologyAction(switchBe, ActionType.CLOSE);
+    private final SwitchPair openSwitchFrCloseSwitchBe = NetworkActionUtils.createSwitchPair(switchFr, switchBe);
+    private final SwitchPair openSwitchBeCloseSwitchFr = NetworkActionUtils.createSwitchPair(switchBe, switchFr);
+    private final PstSetpoint pstFr0 = NetworkActionUtils.createPstSetpoint(pstFr, 0);
+    private final PstSetpoint pstFr5 = NetworkActionUtils.createPstSetpoint(pstFr, 5);
+    private final PstSetpoint pstBe0 = NetworkActionUtils.createPstSetpoint(pstBe, 0);
+    private final PstSetpoint pstBeMinus5 = NetworkActionUtils.createPstSetpoint(pstBe, -5);
+    private final InjectionSetpoint generatorFr0Mw = NetworkActionUtils.createInjectionSetpoint(generatorFr, 0d, Unit.MEGAWATT);
+    private final InjectionSetpoint generatorFr100Mw = NetworkActionUtils.createInjectionSetpoint(generatorFr, 100d, Unit.MEGAWATT);
+    private final InjectionSetpoint generatorFr0A = NetworkActionUtils.createInjectionSetpoint(generatorFr, 0d, Unit.AMPERE);
+    private final InjectionSetpoint generatorFr1000A = NetworkActionUtils.createInjectionSetpoint(generatorFr, 1000d, Unit.AMPERE);
+    private final InjectionSetpoint generatorBe0Mw = NetworkActionUtils.createInjectionSetpoint(generatorBe, 0d, Unit.MEGAWATT);
+    private final InjectionSetpoint generatorBe100Mw = NetworkActionUtils.createInjectionSetpoint(generatorBe, 100d, Unit.MEGAWATT);
+    private final InjectionSetpoint generatorBe0A = NetworkActionUtils.createInjectionSetpoint(generatorBe, 0d, Unit.AMPERE);
+    private final InjectionSetpoint generatorBe1000A = NetworkActionUtils.createInjectionSetpoint(generatorBe, 1000d, Unit.AMPERE);
+    private final List<ElementaryAction> elementaryActions = gatherElementaryActions();
+
+    @Test
+    void testElementaryActionsCompatibility() {
+        assertIncompatibility(openSwitchFr, closeSwitchFr);
+        assertIncompatibility(closeSwitchFr, openSwitchFr);
+        assertIncompatibility(openSwitchBe, closeSwitchBe);
+        assertIncompatibility(closeSwitchBe, openSwitchBe);
+        assertIncompatibility(openSwitchFrCloseSwitchBe, openSwitchBeCloseSwitchFr);
+        assertIncompatibility(openSwitchBeCloseSwitchFr, openSwitchFrCloseSwitchBe);
+        assertIncompatibility(pstFr0, pstFr5);
+        assertIncompatibility(pstFr5, pstFr0);
+        assertIncompatibility(pstBe0, pstBeMinus5);
+        assertIncompatibility(pstBeMinus5, pstBe0);
+        assertIncompatibility(generatorFr0Mw, generatorFr100Mw, generatorFr0A, generatorFr1000A);
+        assertIncompatibility(generatorFr100Mw, generatorFr0Mw, generatorFr0A, generatorFr1000A);
+        assertIncompatibility(generatorFr0A, generatorFr100Mw, generatorFr0Mw, generatorFr1000A);
+        assertIncompatibility(generatorFr1000A, generatorFr0Mw, generatorFr100Mw, generatorFr0A);
+        assertIncompatibility(generatorBe0Mw, generatorBe100Mw, generatorBe0A, generatorBe1000A);
+        assertIncompatibility(generatorBe100Mw, generatorBe0Mw, generatorBe0A, generatorBe1000A);
+        assertIncompatibility(generatorBe0A, generatorBe0Mw, generatorBe100Mw, generatorBe1000A);
+        assertIncompatibility(generatorBe1000A, generatorBe0Mw, generatorBe100Mw, generatorBe0A);
+    }
+
+    private List<ElementaryAction> gatherElementaryActions() {
+        List<ElementaryAction> elementaryActions = new ArrayList<>();
+        elementaryActions.add(openSwitchFr);
+        elementaryActions.add(closeSwitchFr);
+        elementaryActions.add(openSwitchBe);
+        elementaryActions.add(closeSwitchBe);
+        elementaryActions.add(openSwitchFrCloseSwitchBe);
+        elementaryActions.add(openSwitchBeCloseSwitchFr);
+        elementaryActions.add(pstFr0);
+        elementaryActions.add(pstFr5);
+        elementaryActions.add(pstBe0);
+        elementaryActions.add(pstBeMinus5);
+        elementaryActions.add(generatorFr0Mw);
+        elementaryActions.add(generatorFr100Mw);
+        elementaryActions.add(generatorFr0A);
+        elementaryActions.add(generatorFr1000A);
+        elementaryActions.add(generatorBe0Mw);
+        elementaryActions.add(generatorBe100Mw);
+        elementaryActions.add(generatorBe0A);
+        elementaryActions.add(generatorBe1000A);
+        return elementaryActions;
+    }
+
+    private void assertIncompatibility(ElementaryAction elementaryAction, ElementaryAction... incompatibleElementaryActions) {
+        List<ElementaryAction> incompatibleElementaryActionsList = List.of(incompatibleElementaryActions);
+        for (ElementaryAction ea : elementaryActions) {
+            if (incompatibleElementaryActionsList.contains(ea)) {
+                assertFalse(elementaryAction.isCompatibleWith(ea));
+            } else {
+                assertTrue(elementaryAction.isCompatibleWith(ea));
+            }
+        }
+    }
+}

data/crac/crac-api/src/test/java/com/powsybl/openrao/data/cracapi/NetworkActionTest.java

@@ -1,33 +1,39 @@
+/*
+ * Copyright (c) 2024, RTE (http://www.rte-france.com)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
 package com.powsybl.openrao.data.cracapi;
 
+import com.powsybl.openrao.commons.Unit;
 import com.powsybl.openrao.data.cracapi.networkaction.ActionType;
+import com.powsybl.openrao.data.cracapi.networkaction.ElementaryAction;
 import com.powsybl.openrao.data.cracapi.networkaction.InjectionSetpoint;
 import com.powsybl.openrao.data.cracapi.networkaction.NetworkAction;
 import com.powsybl.openrao.data.cracapi.networkaction.PstSetpoint;
 import com.powsybl.openrao.data.cracapi.networkaction.SwitchPair;
 import com.powsybl.openrao.data.cracapi.networkaction.TopologicalAction;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
 
+import java.util.HashSet;
+import java.util.List;
 import java.util.Set;
 
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
+/**
+ * @author Thomas Bouquet {@literal <thomas.bouquet at rte-france.com>}
+ */
 class NetworkActionTest {
     @Test
     void compatibility() {
         NetworkAction hvdcFrEs200Mw = mockHvdcAction(-200d);
         NetworkAction hvdcEsFr200Mw = mockHvdcAction(200d);
-        NetworkAction alignedPsts = Mockito.mock(NetworkAction.class);
-        PstSetpoint pstSetpoint1 = mockPstSetpoint("pst-fr-1", 4);
-        PstSetpoint pstSetpoint2 = mockPstSetpoint("pst-fr-2", 4);
-        PstSetpoint pstSetpoint3 = mockPstSetpoint("pst-fr-3", 4);
-        Mockito.when(alignedPsts.getElementaryActions()).thenReturn(Set.of(pstSetpoint1, pstSetpoint2, pstSetpoint3));
-        NetworkAction switchPairAndPst = Mockito.mock(NetworkAction.class);
-        PstSetpoint pstSetpoint4 = mockPstSetpoint("pst-fr-2", -2);
-        SwitchPair switchPair = mockSwitchPair();
-        Mockito.when(switchPairAndPst.getElementaryActions()).thenReturn(Set.of(pstSetpoint4, switchPair));
+        NetworkAction alignedPsts = mockNetworkAction(mockPstSetpoint("pst-fr-1", 4), mockPstSetpoint("pst-fr-2", 4), mockPstSetpoint("pst-fr-3", 4));
+        NetworkAction switchPairAndPst = mockNetworkAction(mockPstSetpoint("pst-fr-2", -2), mockSwitchPair());
 
         assertTrue(hvdcFrEs200Mw.isCompatibleWith(hvdcFrEs200Mw));
         assertFalse(hvdcFrEs200Mw.isCompatibleWith(hvdcEsFr200Mw));
@@ -38,58 +44,30 @@ void compatibility() {
         assertTrue(hvdcEsFr200Mw.isCompatibleWith(switchPairAndPst));
         assertTrue(alignedPsts.isCompatibleWith(alignedPsts));
         assertFalse(alignedPsts.isCompatibleWith(switchPairAndPst));
-        assertFalse(switchPairAndPst.isCompatibleWith(switchPairAndPst));
+        assertTrue(switchPairAndPst.isCompatibleWith(switchPairAndPst));
     }
 
     private NetworkAction mockHvdcAction(double setpoint) {
-        NetworkAction hvdcAction = Mockito.mock(NetworkAction.class);
-        TopologicalAction topologicalAction1 = mockTopologicalAction("switch-fr");
-        TopologicalAction topologicalAction2 = mockTopologicalAction("switch-es");
-        InjectionSetpoint generatorAction11 = mockInjectionSetpoint("generator-fr-1", setpoint / 2d);
-        InjectionSetpoint generatorAction12 = mockInjectionSetpoint("generator-fr-2", setpoint / 2d);
-        InjectionSetpoint generatorAction21 = mockInjectionSetpoint("generator-es-1", -setpoint / 2d);
-        InjectionSetpoint generatorAction22 = mockInjectionSetpoint("generator-es-2", -setpoint / 2d);
-        Mockito.when(hvdcAction.getElementaryActions()).thenReturn(Set.of(topologicalAction1, topologicalAction2, generatorAction11, generatorAction12, generatorAction21, generatorAction22));
-        Mockito.when(hvdcAction.isCompatibleWith(Mockito.any())).thenCallRealMethod();
-        return hvdcAction;
+        return new NetworkActionUtils.NetworkActionImplTest(Set.of(mockTopologicalAction("switch-fr"), mockTopologicalAction("switch-es"), mockInjectionSetpoint("generator-fr-1", setpoint / 2d), mockInjectionSetpoint("generator-fr-2", setpoint / 2d), mockInjectionSetpoint("generator-es-1", -setpoint / 2d), mockInjectionSetpoint("generator-es-2", -setpoint / 2d)));
+    }
+
+    private NetworkAction mockNetworkAction(ElementaryAction... elementaryActions) {
+        return new NetworkActionUtils.NetworkActionImplTest(new HashSet<>(List.of(elementaryActions)));
     }
 
     private TopologicalAction mockTopologicalAction(String switchId) {
-        TopologicalAction topologicalAction = Mockito.mock(TopologicalAction.class);
-        NetworkElement networkElement = mockNetworkElement(switchId);
-        Mockito.when(topologicalAction.getNetworkElement()).thenReturn(networkElement);
-        Mockito.when(topologicalAction.getActionType()).thenReturn(ActionType.OPEN);
-        return topologicalAction;
+        return new NetworkActionUtils.TopologicalActionImplTest(NetworkActionUtils.createNetworkElement(switchId), ActionType.OPEN);
     }
 
     private InjectionSetpoint mockInjectionSetpoint(String networkElementId, double setpoint) {
-        InjectionSetpoint injectionSetpoint = Mockito.mock(InjectionSetpoint.class);
-        NetworkElement networkElement = mockNetworkElement(networkElementId);
-        Mockito.when(injectionSetpoint.getSetpoint()).thenReturn(setpoint);
-        Mockito.when(injectionSetpoint.getNetworkElement()).thenReturn(networkElement);
-        return injectionSetpoint;
+        return new NetworkActionUtils.InjectionSetpointImplTest(NetworkActionUtils.createNetworkElement(networkElementId), setpoint, Unit.MEGAWATT);
     }
 
     private PstSetpoint mockPstSetpoint(String pstId, int setpoint) {
-        PstSetpoint pstSetpoint = Mockito.mock(PstSetpoint.class);
-        NetworkElement networkElement = mockNetworkElement(pstId);
-        Mockito.when(pstSetpoint.getSetpoint()).thenReturn(setpoint);
-        Mockito.when(pstSetpoint.getNetworkElement()).thenReturn(networkElement);
-        return pstSetpoint;
+        return new NetworkActionUtils.PstSetpointImplTest(NetworkActionUtils.createNetworkElement(pstId), setpoint);
     }
 
     private SwitchPair mockSwitchPair() {
-        SwitchPair switchPair = Mockito.mock(SwitchPair.class);
-        NetworkElement switchToOpen = mockNetworkElement("switch-fr");
-        NetworkElement switchToClose = mockNetworkElement("switch-es");
-        Mockito.when(switchPair.getSwitchToOpen()).thenReturn(switchToOpen);
-        Mockito.when(switchPair.getSwitchToClose()).thenReturn(switchToClose);
-        return switchPair;
-    }
-
-    private NetworkElement mockNetworkElement(String networkElementId) {
-        NetworkElement networkElement = Mockito.mock(NetworkElement.class);
-        Mockito.when(networkElement.getId()).thenReturn(networkElementId);
-        return networkElement;
+        return new NetworkActionUtils.SwitchPairImplTest(NetworkActionUtils.createNetworkElement("switch-fr"), NetworkActionUtils.createNetworkElement("switch-es"));
     }
 }