SecurityAnalysisExecutionBuilderTest.java
/**
* Copyright (c) 2019, 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/.
* SPDX-License-Identifier: MPL-2.0
*/
package com.powsybl.security.execution;
import com.google.auto.service.AutoService;
import com.powsybl.computation.ComputationManager;
import com.powsybl.computation.Partition;
import com.powsybl.contingency.ContingenciesProvider;
import com.powsybl.contingency.Contingency;
import com.powsybl.iidm.network.Network;
import com.powsybl.security.*;
import com.powsybl.security.distributed.DistributedSecurityAnalysisExecution;
import com.powsybl.security.distributed.ExternalSecurityAnalysisConfig;
import com.powsybl.security.distributed.ForwardedSecurityAnalysisExecution;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import java.util.Collections;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.atomic.AtomicReference;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
/**
* @author Sylvain Leclerc {@literal <sylvain.leclerc at rte-france.com>}
*/
class SecurityAnalysisExecutionBuilderTest {
private static AtomicReference<ContingenciesProvider> actualProvider;
private SecurityAnalysisExecutionBuilder builder;
private SecurityAnalysisExecutionInput input;
@BeforeAll
static void setUpClass() {
actualProvider = new AtomicReference<>();
}
@BeforeEach
void setUp() {
Contingency contingency = new Contingency("cont");
ContingenciesProvider provider = network -> Collections.nCopies(10, contingency);
NetworkVariant networkVariant = mock(NetworkVariant.class);
Network network = mock(Network.class);
input = mock(SecurityAnalysisExecutionInput.class);
when(input.getNetworkVariant()).thenReturn(networkVariant);
when(networkVariant.getNetwork()).thenReturn(network);
when(networkVariant.getVariantId()).thenReturn("mock");
builder = new SecurityAnalysisExecutionBuilder(ExternalSecurityAnalysisConfig::new,
"ExecutionBuilderTestProvider",
execInput -> new SecurityAnalysisInput(networkVariant)
.setContingencies(provider));
}
@Test
void checkLocal() {
SecurityAnalysisExecution execution = builder.build();
assertInstanceOf(SecurityAnalysisExecutionImpl.class, execution);
execution.execute(Mockito.mock(ComputationManager.class), input);
assertNotNull(actualProvider.get());
assertEquals(10, actualProvider.get().getContingencies(null).size());
}
@Test
void checkForwarded() {
builder.forward(true);
assertInstanceOf(ForwardedSecurityAnalysisExecution.class, builder.build());
}
@Test
void checkDistributedForwarded() {
builder.forward(true)
.distributed(12);
assertInstanceOf(ForwardedSecurityAnalysisExecution.class, builder.build());
}
@Test
void checkDistributed() {
builder.distributed(12);
assertInstanceOf(DistributedSecurityAnalysisExecution.class, builder.build());
}
@Test
void checkSubtaskHasOnly5Contingencies() {
SecurityAnalysisExecution execution = builder.subTask(new Partition(1, 2)).build();
assertInstanceOf(SecurityAnalysisExecutionImpl.class, execution);
execution.execute(Mockito.mock(ComputationManager.class), input);
assertNotNull(actualProvider.get());
assertEquals(5, actualProvider.get().getContingencies(null).size());
}
@AutoService(SecurityAnalysisProvider.class)
public static class SecurityAnalysisProviderMock implements SecurityAnalysisProvider {
@Override
public CompletableFuture<SecurityAnalysisReport> run(Network network, String workingVariantId, ContingenciesProvider contingenciesProvider, SecurityAnalysisRunParameters runParameters) {
actualProvider.set(contingenciesProvider);
return null;
}
@Override
public String getName() {
return "ExecutionBuilderTestProvider";
}
@Override
public String getVersion() {
return "1.0";
}
}
}