SkippedOptimizationResultImplTest.java

/*
 * Copyright (c) 2023, RTE (http://www.rte-france.com)
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */

package com.powsybl.openrao.searchtreerao.result.impl;

import com.powsybl.openrao.commons.OpenRaoException;
import com.powsybl.openrao.commons.Unit;
import com.powsybl.contingency.Contingency;
import com.powsybl.openrao.data.crac.api.State;
import com.powsybl.openrao.data.crac.api.cnec.FlowCnec;
import com.powsybl.iidm.network.TwoSides;
import com.powsybl.openrao.data.crac.api.networkaction.NetworkAction;
import com.powsybl.openrao.data.crac.api.rangeaction.PstRangeAction;
import com.powsybl.openrao.data.crac.api.rangeaction.RangeAction;
import com.powsybl.openrao.data.raoresult.api.ComputationStatus;
import com.powsybl.sensitivity.SensitivityVariableSet;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;

import java.util.HashSet;
import java.util.Optional;
import java.util.Set;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.mock;

/**
 * @author Godelaine de Montmorillon {@literal <godelaine.demontmorillon at rte-france.com>}
 */
class SkippedOptimizationResultImplTest {
    private final double sensitivityFailureOverCost = 10000; // DEFAULT_SENSITIVITY_FAILURE_OVERCOST value

    @Test
    void testBasicReturns() {
        FlowCnec flowCnec = mock(FlowCnec.class);
        TwoSides side = mock(TwoSides.class);
        Unit unit = mock(Unit.class);
        SensitivityVariableSet sensitivityVariableSet = mock(SensitivityVariableSet.class);
        State state = mock(State.class);
        PstRangeAction pstRangeAction = mock(PstRangeAction.class);
        RangeAction<?> rangeAction = mock(RangeAction.class);

        SkippedOptimizationResultImpl skippedOptimizationResult = new SkippedOptimizationResultImpl(state, new HashSet<>(), new HashSet<>(), ComputationStatus.FAILURE, sensitivityFailureOverCost);

        assertEquals(ComputationStatus.FAILURE, skippedOptimizationResult.getSensitivityStatus());
        assertEquals(ComputationStatus.FAILURE, skippedOptimizationResult.getSensitivityStatus(state));
        assertTrue(skippedOptimizationResult.getContingencies().isEmpty());
        assertTrue(skippedOptimizationResult.getMostLimitingElements(0).isEmpty());
        assertTrue(skippedOptimizationResult.getMostLimitingElements(10).isEmpty());
        assertEquals(sensitivityFailureOverCost, skippedOptimizationResult.getVirtualCost(), 1e-6);
        assertEquals(0, skippedOptimizationResult.getVirtualCost("emptyString"), 1e-6);
        assertEquals(10000, skippedOptimizationResult.getVirtualCost("sensitivity-failure-cost"), 1e-6);
        assertEquals(1, skippedOptimizationResult.getVirtualCostNames().size());
        assertEquals("sensitivity-failure-cost", skippedOptimizationResult.getVirtualCostNames().iterator().next());
        assertThrows(OpenRaoException.class, () -> skippedOptimizationResult.getSensitivityValue(flowCnec, side, rangeAction, unit));
        assertThrows(OpenRaoException.class, () -> skippedOptimizationResult.getSensitivityValue(flowCnec, side, sensitivityVariableSet, unit));
        assertThrows(OpenRaoException.class, () -> skippedOptimizationResult.getFlow(flowCnec, side, unit));
        assertThrows(OpenRaoException.class, () -> skippedOptimizationResult.getCommercialFlow(flowCnec, side, unit));
        assertThrows(OpenRaoException.class, () -> skippedOptimizationResult.getPtdfZonalSum(flowCnec, side));
        assertThrows(OpenRaoException.class, () -> skippedOptimizationResult.getPtdfZonalSums());
        assertThrows(OpenRaoException.class, () -> skippedOptimizationResult.getCostlyElements("emptyString", 10));
        assertThrows(OpenRaoException.class, () -> skippedOptimizationResult.getOptimizedSetpoint(rangeAction, state));
        assertThrows(OpenRaoException.class, () -> skippedOptimizationResult.getOptimizedSetpointsOnState(state));
        assertThrows(OpenRaoException.class, () -> skippedOptimizationResult.getOptimizedTap(pstRangeAction, state));
        assertThrows(OpenRaoException.class, () -> skippedOptimizationResult.getOptimizedTapsOnState(state));
    }

    @Test
    void testDefaultStatus() {
        State state = mock(State.class);
        Optional<Contingency> optContingency = mock(Optional.class);
        Contingency contingency = mock(Contingency.class);
        Mockito.when(state.getContingency()).thenReturn(optContingency);
        Mockito.when(optContingency.isPresent()).thenReturn(true);
        Mockito.when(optContingency.get()).thenReturn(contingency);
        Mockito.when(contingency.getId()).thenReturn("contingencyId");

        SkippedOptimizationResultImpl skippedOptimizationResult = new SkippedOptimizationResultImpl(state, new HashSet<>(), new HashSet<>(), ComputationStatus.DEFAULT, sensitivityFailureOverCost);
        assertEquals(ComputationStatus.DEFAULT, skippedOptimizationResult.getSensitivityStatus());
        assertEquals(Set.of("contingencyId"), skippedOptimizationResult.getContingencies());
    }

    @Test
    void testActivation() {
        State state = mock(State.class);
        NetworkAction na1 = Mockito.mock(NetworkAction.class);
        NetworkAction na2 = Mockito.mock(NetworkAction.class);
        NetworkAction na3 = Mockito.mock(NetworkAction.class);
        RangeAction<?> ra1 = Mockito.mock(RangeAction.class);
        RangeAction<?> ra2 = Mockito.mock(RangeAction.class);
        Set<NetworkAction> networkActions = Set.of(na1, na2);
        Set<RangeAction<?>> rangeActions = Set.of(ra1, ra2);
        SkippedOptimizationResultImpl skippedOptimizationResult = new SkippedOptimizationResultImpl(state, networkActions, rangeActions, ComputationStatus.DEFAULT, sensitivityFailureOverCost);
        assertEquals(networkActions, skippedOptimizationResult.getActivatedNetworkActions());
        assertTrue(skippedOptimizationResult.isActivated(na1));
        assertTrue(skippedOptimizationResult.isActivated(na2));
        assertFalse(skippedOptimizationResult.isActivated(na3));
        assertEquals(rangeActions, skippedOptimizationResult.getRangeActions());
        assertEquals(rangeActions, skippedOptimizationResult.getActivatedRangeActions(state));
    }
}