* ============LICENSE_START=======================================================
* ONAP : APPC
* ================================================================================
- * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
+ * Copyright (C) 2018-2019 Ericsson
+ * ================================================================================
+ * Modifications Copyright (C) 2019 Orange Nokia
* ================================================================================
- * Copyright (C) 2017 Amdocs
- * =============================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* See the License for the specific language governing permissions and
* limitations under the License.
*
- * ECOMP is a trademark and service mark of AT&T Intellectual Property.
* ============LICENSE_END=========================================================
*/
package org.onap.appc.provider;
-import org.junit.After;
-import org.junit.Assert;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import java.util.HashMap;
+import java.util.Map;
import org.junit.Before;
import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.Spy;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.test.AbstractDataBrokerTest;
+import org.mockito.Mockito;
+import org.onap.appc.domainmodel.lcm.ResponseContext;
+import org.onap.appc.domainmodel.lcm.Status;
+import org.onap.appc.requesthandler.objects.RequestHandlerInput;
+import org.onap.appc.requesthandler.objects.RequestHandlerOutput;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RpcRegistration;
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.Action;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ActionStatusInput;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AttachVolumeInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AttachVolumeOutput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AttachVolumeOutputBuilder;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AuditInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AuditOutput;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.CheckLockInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.CheckLockOutput;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigBackupDeleteInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigBackupDeleteOutput;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigBackupInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigBackupOutput;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigExportInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigExportOutput;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigModifyInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigModifyOutput;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigRestoreInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigRestoreOutput;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigScaleOutInput;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigureInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigureOutput;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.DetachVolumeInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.DetachVolumeOutput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.DetachVolumeOutputBuilder;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.DistributeTrafficInput;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.DistributeTrafficCheckInput;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.EvacuateInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.EvacuateOutput;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.HealthCheckInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.HealthCheckOutput;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.LiveUpgradeInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.LiveUpgradeOutput;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.LockInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.LockOutput;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.MigrateInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.MigrateOutput;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.QueryInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.QueryOutput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.QueryOutputBuilder;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.QuiesceTrafficInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.QuiesceTrafficOutput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.QuiesceTrafficOutputBuilder;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ResumeTrafficInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ResumeTrafficOutput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ResumeTrafficOutputBuilder;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradePreCheckInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradePreCheckOutput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradePreCheckOutputBuilder;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeSoftwareInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeSoftwareOutput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeSoftwareOutputBuilder;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradePostCheckInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradePostCheckOutput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradePostCheckOutputBuilder;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeBackupInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeBackupOutput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeBackupOutputBuilder;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeBackoutInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeBackoutOutput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeBackoutOutputBuilder;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RebootInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RebootOutput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RebootOutputBuilder;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RebuildInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RebuildOutput;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RestartInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RestartOutput;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ResumeTrafficInput;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RollbackInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RollbackOutput;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SnapshotInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SnapshotOutput;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SoftwareUploadInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SoftwareUploadOutput;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StartApplicationInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StartApplicationOutput;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StartInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StartOutput;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StopApplicationInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StopApplicationOutput;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StopInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.StopOutput;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SyncInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.SyncOutput;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.TerminateInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.TerminateOutput;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.TestInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.TestOutput;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UnlockInput;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UnlockOutput;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeBackoutInput;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeBackupInput;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradePostCheckInput;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradePreCheckInput;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.UpgradeSoftwareInput;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigScaleInInput;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.DownloadNESwInput;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ActivateNESwInput;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ZULU;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.action.identifiers.ActionIdentifiers;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.action.identifiers.ActionIdentifiersBuilder;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.common.header.CommonHeader;
import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.common.header.CommonHeaderBuilder;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.status.Status;
-import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.status.StatusBuilder;
-import org.opendaylight.yangtools.yang.common.RpcResult;
-import org.onap.appc.domainmodel.lcm.ResponseContext;
-import org.onap.appc.executor.objects.LCMCommandStatus;
-import org.onap.appc.provider.lcm.service.*;
-import org.onap.appc.provider.lcm.util.ValidationService;
-import org.onap.appc.requesthandler.objects.RequestHandlerOutput;
-import org.osgi.framework.FrameworkUtil;
-import org.powermock.api.mockito.PowerMockito;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
-import org.powermock.reflect.Whitebox;
-
-import java.time.Clock;
-import java.time.LocalDateTime;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-import static org.powermock.api.mockito.PowerMockito.mockStatic;
-import static org.powermock.api.mockito.PowerMockito.whenNew;
-
-/**
- * Integration Test class for AppcProviderLcm.
- */
-@RunWith(PowerMockRunner.class)
-@PrepareForTest({FrameworkUtil.class, AppcProviderLcm.class, QueryService.class, VolumeService.class,
- QuiesceTrafficService.class, ValidationService.class})
-public class AppcProviderLcmTest extends AbstractDataBrokerTest {
- private Status successStatus = new StatusBuilder().setCode(400).setMessage("success").build();
- private Status failStatus = new StatusBuilder().setCode(401).setMessage("failure").build();
-
- private AppcProviderLcm appcProviderLcm;
+
+public class AppcProviderLcmTest {
+
+ private interface ParameterizedRpcRegistration extends RpcRegistration<AppcProviderLcmService> {}
private DataBroker dataBroker;
- @Spy
- private ValidationService validationService = ValidationService.getInstance();
- @Mock
- private RequestHandlerOutput requestHandlerOutput;
- @Mock
- private ResponseContext responseContext;
- @Mock
- private org.onap.appc.domainmodel.lcm.Status successlcmStatus;
-
- /**
- * The @Before annotation is defined in the AbstractDataBrokerTest class. The method setupWithDataBroker is invoked
- * from inside the @Before method and is used to initialize the databroker with objects for a test runs. In our case
- * we use this oportunity to create an instance of our provider and initialize it (which registers it as a listener
- * etc). This method runs before every @Test method below.
- */
- @Override
- protected void setupWithDataBroker(DataBroker dataBroker) {
- super.setupWithDataBroker(dataBroker);
-
- this.dataBroker = dataBroker;
- }
+ private NotificationPublishService notificationProviderService;
+ private RpcProviderRegistry rpcProviderRegistry;
+ private BindingAwareBroker.RpcRegistration<AppcProviderLcmService> rpcRegistration;
+ private AppcProviderLcm underTest;
+ private RequestHandlerOutput output;
@Before
- public void setUp() throws Exception {
- //mock appcProviderLcm
- NotificationProviderService nps = mock(NotificationProviderService.class);
- RpcProviderRegistry registry = mock(RpcProviderRegistry.class);
- BindingAwareBroker.RpcRegistration rpcRegistration = mock(BindingAwareBroker.RpcRegistration.class);
- PowerMockito.doReturn(rpcRegistration).when(registry).addRpcImplementation(any(), any());
- appcProviderLcm = spy(new AppcProviderLcm(dataBroker, nps, registry));
- //mock validationService
- mockStatic(ValidationService.class);
- PowerMockito.when(ValidationService.getInstance()).thenReturn(validationService);
-
- doReturn(successlcmStatus).when(responseContext).getStatus();
- doReturn(400).when(successlcmStatus).getCode();
- doReturn("success").when(successlcmStatus).getMessage();
+ public void setupMocksForTests() {
+ dataBroker = mock(DataBroker.class);
+ notificationProviderService = mock(NotificationPublishService.class);
+ rpcProviderRegistry = mock(RpcProviderRegistry.class);
+ rpcRegistration = mock(ParameterizedRpcRegistration.class);
+ Mockito.doReturn(rpcRegistration).when(rpcProviderRegistry).addRpcImplementation(
+ Mockito.any(Class.class), Mockito.any(AppcProviderLcm.class));
+ underTest =
+ new AppcProviderLcm(dataBroker, notificationProviderService, rpcProviderRegistry);
+ output = Mockito.mock(RequestHandlerOutput.class);
+ ResponseContext responseContext = Mockito.mock(ResponseContext.class);
+ Status status = Mockito.mock(Status.class);
+ Mockito.doReturn(200).when(status).getCode();
+ Mockito.doReturn(status).when(responseContext).getStatus();
+ Mockito.doReturn(responseContext).when(output).getResponseContext();
+ }
+
+ @Test
+ public void rebuildTestParseException() {
+ RebuildInput rebuildInput = mock(RebuildInput.class);
+ Mockito.doReturn(Action.Rebuild).when(rebuildInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(rebuildInput).getCommonHeader();
+ assertTrue(underTest.rebuild(rebuildInput).isDone());
}
@Test
- public void testConstructor() throws Exception {
- ExecutorService executorService = Whitebox.getInternalState(appcProviderLcm, "executor");
- Assert.assertNotNull(executorService);
- BindingAwareBroker.RpcRegistration internalRpcRegistration = Whitebox.getInternalState(appcProviderLcm,
- "rpcRegistration");
- Assert.assertNotNull(internalRpcRegistration);
+ public void rebuildTest() {
+ AppcProviderLcm underTestSpy = Mockito.spy(underTest);
+ RebuildInput rebuildInput = mock(RebuildInput.class);
+ Mockito.doReturn(Action.Rebuild).when(rebuildInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(rebuildInput).getCommonHeader();
+ Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(rebuildInput).getActionIdentifiers();
+ Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
+ assertTrue(underTestSpy.rebuild(rebuildInput).isDone());
}
@Test
- public void testClose() throws Exception {
- ExecutorService executorService = spy(Executors.newFixedThreadPool(1));
- Whitebox.setInternalState(appcProviderLcm, "executor", executorService);
- BindingAwareBroker.RpcRegistration rpcRegistration = mock(BindingAwareBroker.RpcRegistration.class);
- Whitebox.setInternalState(appcProviderLcm, "rpcRegistration", rpcRegistration);
- appcProviderLcm.close();
-
- verify(executorService, times(1)).shutdown();
- verify(rpcRegistration, times(1)).close();
+ public void restartTestParseException() {
+ RestartInput restartInput = mock(RestartInput.class);
+ Mockito.doReturn(Action.Restart).when(restartInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(restartInput).getCommonHeader();
+ assertTrue(underTest.restart(restartInput).isDone());
}
@Test
- public void testRebuild() throws Exception {
- // Validation success
- doReturn("Success").when(successlcmStatus).getMessage();
- doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
- doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
- doReturn(null).when(validationService).validateInput(any(), any(), any());
-
- RebuildInput rebuildInput = mock(RebuildInput.class);
- doReturn(newCommonHeader("request-id-test")).when(rebuildInput).getCommonHeader();
- doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
- .when(rebuildInput).getActionIdentifiers();
-
- Future<RpcResult<RebuildOutput>> results = appcProviderLcm.rebuild(rebuildInput);
- Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
- Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // Validation failed
- doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
- results = appcProviderLcm.rebuild(rebuildInput);
- Assert.assertEquals(failStatus, results.get().getResult().getStatus());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // parse exception
- doReturn(null).when(validationService).validateInput(any(), any(), any());
- doReturn(null).when(rebuildInput).getActionIdentifiers();
- results = appcProviderLcm.rebuild(rebuildInput);
- Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
- == results.get().getResult().getStatus().getCode());
- verify(appcProviderLcm, times(1)).executeRequest(any());
- }
-
- @Test
- public void testRestart() throws Exception {
- // Validation success
- doReturn("Success").when(successlcmStatus).getMessage();
- doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
- doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
- doReturn(null).when(validationService).validateInput(any(), any(), any());
-
+ public void restartTest() {
+ AppcProviderLcm underTestSpy = Mockito.spy(underTest);
RestartInput restartInput = mock(RestartInput.class);
- doReturn(newCommonHeader("request-id-test")).when(restartInput).getCommonHeader();
- doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
- .when(restartInput).getActionIdentifiers();
-
- Future<RpcResult<RestartOutput>> results = appcProviderLcm.restart(restartInput);
- Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
- Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // Validation failed
- doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
- results = appcProviderLcm.restart(restartInput);
- Assert.assertEquals(failStatus, results.get().getResult().getStatus());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // parse exception
- doReturn(null).when(validationService).validateInput(any(), any(), any());
- doReturn(null).when(restartInput).getActionIdentifiers();
- results = appcProviderLcm.restart(restartInput);
- Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
- == results.get().getResult().getStatus().getCode());
- verify(appcProviderLcm, times(1)).executeRequest(any());
- }
-
- @Test
- public void testStartApplication() throws Exception {
- // Validation success
- doReturn("Success").when(successlcmStatus).getMessage();
- doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
- doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
- doReturn(null).when(validationService).validateInput(any(), any(), any());
+ Mockito.doReturn(Action.Restart).when(restartInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(restartInput).getCommonHeader();
+ Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(restartInput).getActionIdentifiers();
+ Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
+ assertTrue(underTestSpy.restart(restartInput).isDone());
+ }
+ @Test
+ public void startApplicationTestParseException() {
StartApplicationInput startApplicationInput = mock(StartApplicationInput.class);
- doReturn(newCommonHeader("request-id-test")).when(startApplicationInput).getCommonHeader();
- doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
- .when(startApplicationInput).getActionIdentifiers();
-
- Future<RpcResult<StartApplicationOutput>> results = appcProviderLcm.startApplication(startApplicationInput);
- Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
- Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // Validation failed
- doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
- results = appcProviderLcm.startApplication(startApplicationInput);
- Assert.assertEquals(failStatus, results.get().getResult().getStatus());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // parse exception
- doReturn(null).when(validationService).validateInput(any(), any(), any());
- doReturn(null).when(startApplicationInput).getActionIdentifiers();
- results = appcProviderLcm.startApplication(startApplicationInput);
- Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
- == results.get().getResult().getStatus().getCode());
- verify(appcProviderLcm, times(1)).executeRequest(any());
- }
-
- @Test
- public void testMigrate() throws Exception {
- // Validation success
- doReturn("Success").when(successlcmStatus).getMessage();
- doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
- doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
- doReturn(null).when(validationService).validateInput(any(), any(), any());
+ Mockito.doReturn(Action.StartApplication).when(startApplicationInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(startApplicationInput)
+ .getCommonHeader();
+ assertTrue(underTest.startApplication(startApplicationInput).isDone());
+ }
+ @Test
+ public void startApplicationTest() {
+ AppcProviderLcm underTestSpy = Mockito.spy(underTest);
+ StartApplicationInput startApplicationInput = mock(StartApplicationInput.class);
+ Mockito.doReturn(Action.StartApplication).when(startApplicationInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(startApplicationInput).getCommonHeader();
+ Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(startApplicationInput).getActionIdentifiers();
+ Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
+ assertTrue(underTestSpy.startApplication(startApplicationInput).isDone());
+ }
+
+ @Test
+ public void migrateTestParseException() {
MigrateInput migrateInput = mock(MigrateInput.class);
- doReturn(newCommonHeader("request-id-test")).when(migrateInput).getCommonHeader();
- doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
- .when(migrateInput).getActionIdentifiers();
-
- Future<RpcResult<MigrateOutput>> results = appcProviderLcm.migrate(migrateInput);
- Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
- Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // Validation failed
- doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
- results = appcProviderLcm.migrate(migrateInput);
- Assert.assertEquals(failStatus, results.get().getResult().getStatus());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // parse exception
- doReturn(null).when(validationService).validateInput(any(), any(), any());
- doReturn(null).when(migrateInput).getActionIdentifiers();
- results = appcProviderLcm.migrate(migrateInput);
- Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
- == results.get().getResult().getStatus().getCode());
- verify(appcProviderLcm, times(1)).executeRequest(any());
- }
-
- @Test
- public void testEvacuate() throws Exception {
- // Validation success
- doReturn("Success").when(successlcmStatus).getMessage();
- doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
- doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
- doReturn(null).when(validationService).validateInput(any(), any(), any());
+ Mockito.doReturn(Action.Migrate).when(migrateInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(migrateInput).getCommonHeader();
+ assertTrue(underTest.migrate(migrateInput).isDone());
+ }
+
+ @Test
+ public void migrateTest() {
+ AppcProviderLcm underTestSpy = Mockito.spy(underTest);
+ MigrateInput migrateInput = mock(MigrateInput.class);
+ Mockito.doReturn(Action.Migrate).when(migrateInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(migrateInput).getCommonHeader();
+ Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(migrateInput).getActionIdentifiers();
+ Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
+ assertTrue(underTestSpy.migrate(migrateInput).isDone());
+ }
+ @Test
+ public void evacuateTestParseException() {
+ EvacuateInput evacuateInput = mock(EvacuateInput.class);
+ Mockito.doReturn(Action.Evacuate).when(evacuateInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(evacuateInput).getCommonHeader();
+ assertTrue(underTest.evacuate(evacuateInput).isDone());
+ }
+
+ @Test
+ public void evacuateTest() {
+ AppcProviderLcm underTestSpy = Mockito.spy(underTest);
EvacuateInput evacuateInput = mock(EvacuateInput.class);
- doReturn(newCommonHeader("request-id-test")).when(evacuateInput).getCommonHeader();
- doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
- .when(evacuateInput).getActionIdentifiers();
-
- Future<RpcResult<EvacuateOutput>> results = appcProviderLcm.evacuate(evacuateInput);
- Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
- Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // Validation failed
- doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
- results = appcProviderLcm.evacuate(evacuateInput);
- Assert.assertEquals(failStatus, results.get().getResult().getStatus());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // parse exception
- doReturn(null).when(validationService).validateInput(any(), any(), any());
- doReturn(null).when(evacuateInput).getActionIdentifiers();
- results = appcProviderLcm.evacuate(evacuateInput);
- Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
- == results.get().getResult().getStatus().getCode());
- verify(appcProviderLcm, times(1)).executeRequest(any());
- }
-
- @Test
- public void testSnapshot() throws Exception {
- // Validation success
- doReturn("Success").when(successlcmStatus).getMessage();
- doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
- doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
- doReturn(null).when(validationService).validateInput(any(), any(), any());
+ Mockito.doReturn(Action.Evacuate).when(evacuateInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(evacuateInput).getCommonHeader();
+ Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(evacuateInput).getActionIdentifiers();
+ Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
+ assertTrue(underTestSpy.evacuate(evacuateInput).isDone());
+ }
+ @Test
+ public void snapshotTestParseException() {
SnapshotInput snapshotInput = mock(SnapshotInput.class);
- doReturn(newCommonHeader("request-id-test")).when(snapshotInput).getCommonHeader();
- doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
- .when(snapshotInput).getActionIdentifiers();
-
- Future<RpcResult<SnapshotOutput>> results = appcProviderLcm.snapshot(snapshotInput);
- Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
- Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // Validation failed
- doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
- results = appcProviderLcm.snapshot(snapshotInput);
- Assert.assertEquals(failStatus, results.get().getResult().getStatus());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // parse exception
- doReturn(null).when(validationService).validateInput(any(), any(), any());
- doReturn(null).when(snapshotInput).getActionIdentifiers();
- results = appcProviderLcm.snapshot(snapshotInput);
- Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
- == results.get().getResult().getStatus().getCode());
- verify(appcProviderLcm, times(1)).executeRequest(any());
- }
-
- @Test
- public void testRollback() throws Exception {
- // Validation success
- doReturn("Success").when(successlcmStatus).getMessage();
- doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
- doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
- doReturn(null).when(validationService).validateInput(any(), any(), any());
+ Mockito.doReturn(Action.Snapshot).when(snapshotInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(snapshotInput).getCommonHeader();
+ assertTrue(underTest.snapshot(snapshotInput).isDone());
+ }
- RollbackInput rollbackInput = mock(RollbackInput.class);
- doReturn(newCommonHeader("request-id-test")).when(rollbackInput).getCommonHeader();
- doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
- .when(rollbackInput).getActionIdentifiers();
-
- Future<RpcResult<RollbackOutput>> results = appcProviderLcm.rollback(rollbackInput);
- Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
- Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // Validation failed
- doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
- results = appcProviderLcm.rollback(rollbackInput);
- Assert.assertEquals(failStatus, results.get().getResult().getStatus());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // parse exception
- doReturn(null).when(validationService).validateInput(any(), any(), any());
- doReturn(null).when(rollbackInput).getActionIdentifiers();
- results = appcProviderLcm.rollback(rollbackInput);
- Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
- == results.get().getResult().getStatus().getCode());
- verify(appcProviderLcm, times(1)).executeRequest(any());
- }
-
- @Test
- public void testSync() throws Exception {
- // Validation success
- doReturn("Success").when(successlcmStatus).getMessage();
- doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
- doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
- doReturn(null).when(validationService).validateInput(any(), any(), any());
+ @Test
+ public void snapshotTest() {
+ AppcProviderLcm underTestSpy = Mockito.spy(underTest);
+ SnapshotInput snapshotInput = mock(SnapshotInput.class);
+ Mockito.doReturn(Action.Snapshot).when(snapshotInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(snapshotInput).getCommonHeader();
+ Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(snapshotInput).getActionIdentifiers();
+ Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
+ assertTrue(underTestSpy.snapshot(snapshotInput).isDone());
+ }
- SyncInput syncInput = mock(SyncInput.class);
- doReturn(newCommonHeader("request-id-test")).when(syncInput).getCommonHeader();
- doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
- .when(syncInput).getActionIdentifiers();
-
- Future<RpcResult<SyncOutput>> results = appcProviderLcm.sync(syncInput);
- Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
- Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // Validation failed
- doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
- results = appcProviderLcm.sync(syncInput);
- Assert.assertEquals(failStatus, results.get().getResult().getStatus());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // parse exception
- doReturn(null).when(validationService).validateInput(any(), any(), any());
- doReturn(null).when(syncInput).getActionIdentifiers();
- results = appcProviderLcm.sync(syncInput);
- Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
- == results.get().getResult().getStatus().getCode());
- verify(appcProviderLcm, times(1)).executeRequest(any());
- }
-
- @Test
- public void testTerminate() throws Exception {
- // Validation success
- doReturn("Success").when(successlcmStatus).getMessage();
- doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
- doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
- doReturn(null).when(validationService).validateInput(any(), any(), any());
+ @Test
+ public void rollbackTestParseException() {
+ RollbackInput rollbackInput = mock(RollbackInput.class);
+ Mockito.doReturn(Action.Rollback).when(rollbackInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(rollbackInput).getCommonHeader();
+ assertTrue(underTest.rollback(rollbackInput).isDone());
+ }
- TerminateInput terminateInput = mock(TerminateInput.class);
- doReturn(newCommonHeader("request-id-test")).when(terminateInput).getCommonHeader();
- doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
- .when(terminateInput).getActionIdentifiers();
-
- Future<RpcResult<TerminateOutput>> results = appcProviderLcm.terminate(terminateInput);
- Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
- Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // Validation failed
- doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
- results = appcProviderLcm.terminate(terminateInput);
- Assert.assertEquals(failStatus, results.get().getResult().getStatus());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // parse exception
- doReturn(null).when(validationService).validateInput(any(), any(), any());
- doReturn(null).when(terminateInput).getActionIdentifiers();
- results = appcProviderLcm.terminate(terminateInput);
- Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
- == results.get().getResult().getStatus().getCode());
- verify(appcProviderLcm, times(1)).executeRequest(any());
- }
-
- @Test
- public void testConfigure() throws Exception {
- // Validation success
- doReturn("Success").when(successlcmStatus).getMessage();
- doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
- doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
- doReturn(null).when(validationService).validateInput(any(), any(), any());
+ @Test
+ public void rollbackTest() {
+ AppcProviderLcm underTestSpy = Mockito.spy(underTest);
+ RollbackInput rollbackInput = mock(RollbackInput.class);
+ Mockito.doReturn(Action.Rollback).when(rollbackInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(rollbackInput).getCommonHeader();
+ Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(rollbackInput).getActionIdentifiers();
+ Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
+ assertTrue(underTestSpy.rollback(rollbackInput).isDone());
+ }
- ConfigureInput configureInput = mock(ConfigureInput.class);
- doReturn(newCommonHeader("request-id-test")).when(configureInput).getCommonHeader();
- doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
- .when(configureInput).getActionIdentifiers();
-
- Future<RpcResult<ConfigureOutput>> results = appcProviderLcm.configure(configureInput);
- Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
- Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // Validation failed
- doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
- results = appcProviderLcm.configure(configureInput);
- Assert.assertEquals(failStatus, results.get().getResult().getStatus());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // parse exception
- doReturn(null).when(validationService).validateInput(any(), any(), any());
- doReturn(null).when(configureInput).getActionIdentifiers();
- results = appcProviderLcm.configure(configureInput);
- Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
- == results.get().getResult().getStatus().getCode());
- verify(appcProviderLcm, times(1)).executeRequest(any());
- }
-
- @Test
- public void testConfigModify() throws Exception {
- // Validation success
- doReturn("Success").when(successlcmStatus).getMessage();
- doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
- doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
- doReturn(null).when(validationService).validateInput(any(), any(), any());
+ @Test
+ public void syncTestParseException() {
+ SyncInput syncInput = mock(SyncInput.class);
+ Mockito.doReturn(Action.Sync).when(syncInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(syncInput).getCommonHeader();
+ assertTrue(underTest.sync(syncInput).isDone());
+ }
- ConfigModifyInput configModifyInput = mock(ConfigModifyInput.class);
- doReturn(newCommonHeader("request-id-test")).when(configModifyInput).getCommonHeader();
- doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
- .when(configModifyInput).getActionIdentifiers();
-
- Future<RpcResult<ConfigModifyOutput>> results = appcProviderLcm.configModify(configModifyInput);
- Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
- Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // Validation failed
- doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
- results = appcProviderLcm.configModify(configModifyInput);
- Assert.assertEquals(failStatus, results.get().getResult().getStatus());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // parse exception
- doReturn(null).when(validationService).validateInput(any(), any(), any());
- doReturn(null).when(configModifyInput).getActionIdentifiers();
- results = appcProviderLcm.configModify(configModifyInput);
- Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
- == results.get().getResult().getStatus().getCode());
- verify(appcProviderLcm, times(1)).executeRequest(any());
- }
-
- @Test
- public void testConfigRestore() throws Exception {
- // Validation success
- doReturn("Success").when(successlcmStatus).getMessage();
- doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
- doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
- doReturn(null).when(validationService).validateInput(any(), any(), any());
+ @Test
+ public void syncTest() {
+ AppcProviderLcm underTestSpy = Mockito.spy(underTest);
+ SyncInput syncInput = mock(SyncInput.class);
+ Mockito.doReturn(Action.Sync).when(syncInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(syncInput).getCommonHeader();
+ Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(syncInput).getActionIdentifiers();
+ Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
+ assertTrue(underTestSpy.sync(syncInput).isDone());
+ }
- ConfigRestoreInput configRestoreInput = mock(ConfigRestoreInput.class);
- doReturn(newCommonHeader("request-id-test")).when(configRestoreInput).getCommonHeader();
- doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
- .when(configRestoreInput).getActionIdentifiers();
-
- Future<RpcResult<ConfigRestoreOutput>> results = appcProviderLcm.configRestore(configRestoreInput);
- Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
- Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // Validation failed
- doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
- results = appcProviderLcm.configRestore(configRestoreInput);
- Assert.assertEquals(failStatus, results.get().getResult().getStatus());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // parse exception
- doReturn(null).when(validationService).validateInput(any(), any(), any());
- doReturn(null).when(configRestoreInput).getActionIdentifiers();
- results = appcProviderLcm.configRestore(configRestoreInput);
- Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
- == results.get().getResult().getStatus().getCode());
- verify(appcProviderLcm, times(1)).executeRequest(any());
- }
-
- @Test
- public void testTest() throws Exception {
- // Validation success
- doReturn("Success").when(successlcmStatus).getMessage();
- doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
- doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
- doReturn(null).when(validationService).validateInput(any(), any(), any());
+ @Test
+ public void queryTest() {
+ QueryInput queryInput = mock(QueryInput.class);
+ Mockito.doReturn(Action.Query).when(queryInput).getAction();
+ assertTrue(underTest.query(queryInput).isDone());
+ }
- TestInput testInput = mock(TestInput.class);
- doReturn(newCommonHeader("request-id-test")).when(testInput).getCommonHeader();
- doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
- .when(testInput).getActionIdentifiers();
-
- Future<RpcResult<TestOutput>> results = appcProviderLcm.test(testInput);
- Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
- Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // Validation failed
- doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
- results = appcProviderLcm.test(testInput);
- Assert.assertEquals(failStatus, results.get().getResult().getStatus());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // parse exception
- doReturn(null).when(validationService).validateInput(any(), any(), any());
- doReturn(null).when(testInput).getActionIdentifiers();
- results = appcProviderLcm.test(testInput);
- Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
- == results.get().getResult().getStatus().getCode());
- verify(appcProviderLcm, times(1)).executeRequest(any());
- }
-
- @Test
- public void testStop() throws Exception {
- // Validation success
- doReturn("Success").when(successlcmStatus).getMessage();
- doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
- doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
- doReturn(null).when(validationService).validateInput(any(), any(), any());
+ @Test
+ public void attachVolumeTest() {
+ AttachVolumeInput attachVolumeInput = mock(AttachVolumeInput.class);
+ Mockito.doReturn(Action.AttachVolume).when(attachVolumeInput).getAction();
+ assertTrue(underTest.attachVolume(attachVolumeInput).isDone());
+ }
- StopInput stopInput = mock(StopInput.class);
- doReturn(newCommonHeader("request-id-stop")).when(stopInput).getCommonHeader();
- doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
- .when(stopInput).getActionIdentifiers();
-
- Future<RpcResult<StopOutput>> results = appcProviderLcm.stop(stopInput);
- Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
- Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // Validation failed
- doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
- results = appcProviderLcm.stop(stopInput);
- Assert.assertEquals(failStatus, results.get().getResult().getStatus());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // parse exception
- doReturn(null).when(validationService).validateInput(any(), any(), any());
- doReturn(null).when(stopInput).getActionIdentifiers();
- results = appcProviderLcm.stop(stopInput);
- Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
- == results.get().getResult().getStatus().getCode());
- verify(appcProviderLcm, times(1)).executeRequest(any());
- }
-
- @Test
- public void testStart() throws Exception {
- // Validation success
- doReturn("Success").when(successlcmStatus).getMessage();
- doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
- doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
- doReturn(null).when(validationService).validateInput(any(), any(), any());
+ @Test
+ public void rebootTest() {
+ RebootInput rebootInput = mock(RebootInput.class);
+ Mockito.doReturn(Action.Reboot).when(rebootInput).getAction();
+ assertTrue(underTest.reboot(rebootInput).isDone());
+ }
- StartInput startInput = mock(StartInput.class);
- doReturn(newCommonHeader("request-id-start")).when(startInput).getCommonHeader();
- doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
- .when(startInput).getActionIdentifiers();
-
- Future<RpcResult<StartOutput>> results = appcProviderLcm.start(startInput);
- Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
- Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // Validation failed
- doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
- results = appcProviderLcm.start(startInput);
- Assert.assertEquals(failStatus, results.get().getResult().getStatus());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // parse exception
- doReturn(null).when(validationService).validateInput(any(), any(), any());
- doReturn(null).when(startInput).getActionIdentifiers();
- results = appcProviderLcm.start(startInput);
- Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
- == results.get().getResult().getStatus().getCode());
- verify(appcProviderLcm, times(1)).executeRequest(any());
- }
-
- @Test
- public void testAudit() throws Exception {
- // Validation success
- doReturn("Success").when(successlcmStatus).getMessage();
- doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
- doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
- doReturn(null).when(validationService).validateInput(any(), any(), any());
+ @Test
+ public void detachVolumeTest() {
+ DetachVolumeInput detachVolumeInput = mock(DetachVolumeInput.class);
+ Mockito.doReturn(Action.DetachVolume).when(detachVolumeInput).getAction();
+ assertTrue(underTest.detachVolume(detachVolumeInput).isDone());
+ }
- AuditInput auditInput = mock(AuditInput.class);
- doReturn(newCommonHeader("request-id-aduit")).when(auditInput).getCommonHeader();
- doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
- .when(auditInput).getActionIdentifiers();
-
- Future<RpcResult<AuditOutput>> results = appcProviderLcm.audit(auditInput);
- Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
- Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // Validation failed
- doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
- results = appcProviderLcm.audit(auditInput);
- Assert.assertEquals(failStatus, results.get().getResult().getStatus());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // parse exception
- doReturn(null).when(validationService).validateInput(any(), any(), any());
- doReturn(null).when(auditInput).getActionIdentifiers();
- results = appcProviderLcm.audit(auditInput);
- Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
- == results.get().getResult().getStatus().getCode());
- verify(appcProviderLcm, times(1)).executeRequest(any());
- }
-
- @Test
- public void testSoftwareUpload() throws Exception {
- // Validation success
- doReturn("Success").when(successlcmStatus).getMessage();
- doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
- doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
- doReturn(null).when(validationService).validateInput(any(), any(), any());
+ @Test
+ public void quiesceTrafficTest() {
+ QuiesceTrafficInput quiesceTrafficInput = mock(QuiesceTrafficInput.class);
+ Mockito.doReturn(Action.QuiesceTraffic).when(quiesceTrafficInput).getAction();
+ assertTrue(underTest.quiesceTraffic(quiesceTrafficInput).isDone());
+ }
- SoftwareUploadInput softwareUploadInput = mock(SoftwareUploadInput.class);
- doReturn(newCommonHeader("request-id-aduit")).when(softwareUploadInput).getCommonHeader();
- doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
- .when(softwareUploadInput).getActionIdentifiers();
-
- Future<RpcResult<SoftwareUploadOutput>> results = appcProviderLcm.softwareUpload(softwareUploadInput);
- Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
- Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // Validation failed
- doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
- results = appcProviderLcm.softwareUpload(softwareUploadInput);
- Assert.assertEquals(failStatus, results.get().getResult().getStatus());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // parse exception
- doReturn(null).when(validationService).validateInput(any(), any(), any());
- doReturn(null).when(softwareUploadInput).getActionIdentifiers();
- results = appcProviderLcm.softwareUpload(softwareUploadInput);
- Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
- == results.get().getResult().getStatus().getCode());
- verify(appcProviderLcm, times(1)).executeRequest(any());
- }
-
- @Test
- public void testHealthCheck() throws Exception {
- // Validation success
- doReturn("Success").when(successlcmStatus).getMessage();
- doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
- doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
- doReturn(null).when(validationService).validateInput(any(), any(), any());
+ @Test
+ public void resumeTrafficTest() {
+ ResumeTrafficInput resumeTrafficInput = mock(ResumeTrafficInput.class);
+ Mockito.doReturn(Action.ResumeTraffic).when(resumeTrafficInput).getAction();
+ assertTrue(underTest.resumeTraffic(resumeTrafficInput).isDone());
+ }
- HealthCheckInput healthCheckInput = mock(HealthCheckInput.class);
- doReturn(newCommonHeader("request-id-aduit")).when(healthCheckInput).getCommonHeader();
- doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
- .when(healthCheckInput).getActionIdentifiers();
-
- Future<RpcResult<HealthCheckOutput>> results = appcProviderLcm.healthCheck(healthCheckInput);
- Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
- Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // Validation failed
- doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
- results = appcProviderLcm.healthCheck(healthCheckInput);
- Assert.assertEquals(failStatus, results.get().getResult().getStatus());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // parse exception
- doReturn(null).when(validationService).validateInput(any(), any(), any());
- doReturn(null).when(healthCheckInput).getActionIdentifiers();
- results = appcProviderLcm.healthCheck(healthCheckInput);
- Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
- == results.get().getResult().getStatus().getCode());
- verify(appcProviderLcm, times(1)).executeRequest(any());
- }
-
- @Test
- public void testLiveUpgrade() throws Exception {
- // Validation success
- doReturn("Success").when(successlcmStatus).getMessage();
- doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
- doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
- doReturn(null).when(validationService).validateInput(any(), any(), any());
+ @Test
+ public void distributeTrafficTest() {
+ DistributeTrafficInput distributeTrafficInput = mock(DistributeTrafficInput.class);
+ Mockito.doReturn(Action.DistributeTraffic).when(distributeTrafficInput).getAction();
+ assertTrue(underTest.distributeTraffic(distributeTrafficInput).isDone());
+ }
- LiveUpgradeInput liveUpgradeInput = mock(LiveUpgradeInput.class);
- doReturn(newCommonHeader("request-id-aduit")).when(liveUpgradeInput).getCommonHeader();
- doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
- .when(liveUpgradeInput).getActionIdentifiers();
-
- Future<RpcResult<LiveUpgradeOutput>> results = appcProviderLcm.liveUpgrade(liveUpgradeInput);
- Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
- Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // Validation failed
- doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
- results = appcProviderLcm.liveUpgrade(liveUpgradeInput);
- Assert.assertEquals(failStatus, results.get().getResult().getStatus());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // parse exception
- doReturn(null).when(validationService).validateInput(any(), any(), any());
- doReturn(null).when(liveUpgradeInput).getActionIdentifiers();
- results = appcProviderLcm.liveUpgrade(liveUpgradeInput);
- Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
- == results.get().getResult().getStatus().getCode());
- verify(appcProviderLcm, times(1)).executeRequest(any());
- }
-
- @Test
- public void testLock() throws Exception {
- // Validation success
- doReturn("Success").when(successlcmStatus).getMessage();
- doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
- doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
- doReturn(null).when(validationService).validateInput(any(), any(), any());
+ @Test
+ public void distributeTrafficCheckTest() {
+ DistributeTrafficCheckInput distributeTrafficCheckInput = mock(DistributeTrafficCheckInput.class);
+ Mockito.doReturn(Action.DistributeTrafficCheck).when(distributeTrafficCheckInput).getAction();
+ assertTrue(underTest.distributeTrafficCheck(distributeTrafficCheckInput).isDone());
+ }
- LockInput lockInput = mock(LockInput.class);
- doReturn(newCommonHeader("request-id-aduit")).when(lockInput).getCommonHeader();
- doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
- .when(lockInput).getActionIdentifiers();
-
- Future<RpcResult<LockOutput>> results = appcProviderLcm.lock(lockInput);
- Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
- Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // Validation failed
- doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
- results = appcProviderLcm.lock(lockInput);
- Assert.assertEquals(failStatus, results.get().getResult().getStatus());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // parse exception
- doReturn(null).when(validationService).validateInput(any(), any(), any());
- doReturn(null).when(lockInput).getActionIdentifiers();
- results = appcProviderLcm.lock(lockInput);
- Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
- == results.get().getResult().getStatus().getCode());
- verify(appcProviderLcm, times(1)).executeRequest(any());
- }
-
- @Test
- public void testUnlock() throws Exception {
- // Validation success
- doReturn("Success").when(successlcmStatus).getMessage();
- doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
- doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
- doReturn(null).when(validationService).validateInput(any(), any(), any());
+ @Test
+ public void upgradePreCheckInputTest() {
+ UpgradePreCheckInput upgradePreCheckInput = mock(UpgradePreCheckInput.class);
+ Mockito.doReturn(Action.UpgradePreCheck).when(upgradePreCheckInput).getAction();
+ assertTrue(underTest.upgradePreCheck(upgradePreCheckInput).isDone());
+ }
- UnlockInput unlockInput = mock(UnlockInput.class);
- doReturn(newCommonHeader("request-id-aduit")).when(unlockInput).getCommonHeader();
- doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
- .when(unlockInput).getActionIdentifiers();
-
- Future<RpcResult<UnlockOutput>> results = appcProviderLcm.unlock(unlockInput);
- Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
- Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // Validation failed
- doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
- results = appcProviderLcm.unlock(unlockInput);
- Assert.assertEquals(failStatus, results.get().getResult().getStatus());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // parse exception
- doReturn(null).when(validationService).validateInput(any(), any(), any());
- doReturn(null).when(unlockInput).getActionIdentifiers();
- results = appcProviderLcm.unlock(unlockInput);
- Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
- == results.get().getResult().getStatus().getCode());
- verify(appcProviderLcm, times(1)).executeRequest(any());
- }
-
- @Test
- public void testCheckLock() throws Exception {
- // Validation success
- doReturn("Success").when(successlcmStatus).getMessage();
- Map<String, String> additionalContext = new HashMap<>();
- additionalContext.put("locked", "true");
- doReturn(additionalContext).when(responseContext).getAdditionalContext();
- doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
- doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
- doReturn(null).when(validationService).validateInput(any(), any(), any());
- CheckLockInput checkLockInput = mock(CheckLockInput.class);
- doReturn(newCommonHeader("request-id-aduit")).when(checkLockInput).getCommonHeader();
- doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
- .when(checkLockInput).getActionIdentifiers();
-
- Future<RpcResult<CheckLockOutput>> results = appcProviderLcm.checkLock(checkLockInput);
- Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
- Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // Validation failed
- doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
- results = appcProviderLcm.checkLock(checkLockInput);
- Assert.assertEquals(failStatus, results.get().getResult().getStatus());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // parse exception
- doReturn(null).when(validationService).validateInput(any(), any(), any());
- doReturn(null).when(checkLockInput).getActionIdentifiers();
- results = appcProviderLcm.checkLock(checkLockInput);
- Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
- == results.get().getResult().getStatus().getCode());
- verify(appcProviderLcm, times(1)).executeRequest(any());
- }
-
- @Test
- public void testConfigBackup() throws Exception {
- // Validation success
- doReturn("Success").when(successlcmStatus).getMessage();
- doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
- doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
- doReturn(null).when(validationService).validateInput(any(), any(), any());
+ @Test
+ public void upgradeSoftwareTest() {
+ UpgradeSoftwareInput upgradeSoftwareInput = mock(UpgradeSoftwareInput.class);
+ Mockito.doReturn(Action.UpgradeSoftware).when(upgradeSoftwareInput).getAction();
+ assertTrue(underTest.upgradeSoftware(upgradeSoftwareInput).isDone());
+ }
- ConfigBackupInput configBackupInput = mock(ConfigBackupInput.class);
- doReturn(newCommonHeader("request-id-aduit")).when(configBackupInput).getCommonHeader();
- doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
- .when(configBackupInput).getActionIdentifiers();
-
- Future<RpcResult<ConfigBackupOutput>> results = appcProviderLcm.configBackup(configBackupInput);
- Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
- Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // Validation failed
- doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
- results = appcProviderLcm.configBackup(configBackupInput);
- Assert.assertEquals(failStatus, results.get().getResult().getStatus());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // parse exception
- doReturn(null).when(validationService).validateInput(any(), any(), any());
- doReturn(null).when(configBackupInput).getActionIdentifiers();
- results = appcProviderLcm.configBackup(configBackupInput);
- Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
- == results.get().getResult().getStatus().getCode());
- verify(appcProviderLcm, times(1)).executeRequest(any());
- }
-
- @Test
- public void testConfigBackupDelete() throws Exception {
- // Validation success
- doReturn("Success").when(successlcmStatus).getMessage();
- doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
- doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
- doReturn(null).when(validationService).validateInput(any(), any(), any());
+ @Test
+ public void upgradePostCheckTest() {
+ UpgradePostCheckInput upgradePostCheckInput = mock(UpgradePostCheckInput.class);
+ Mockito.doReturn(Action.UpgradePostCheck).when(upgradePostCheckInput).getAction();
+ assertTrue(underTest.upgradePostCheck(upgradePostCheckInput).isDone());
+ }
- ConfigBackupDeleteInput configBackupDeleteInput = mock(ConfigBackupDeleteInput.class);
- doReturn(newCommonHeader("request-id-aduit")).when(configBackupDeleteInput).getCommonHeader();
- doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
- .when(configBackupDeleteInput).getActionIdentifiers();
-
- Future<RpcResult<ConfigBackupDeleteOutput>> results = appcProviderLcm.configBackupDelete
- (configBackupDeleteInput);
- Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
- Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // Validation failed
- doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
- results = appcProviderLcm.configBackupDelete(configBackupDeleteInput);
- Assert.assertEquals(failStatus, results.get().getResult().getStatus());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // parse exception
- doReturn(null).when(validationService).validateInput(any(), any(), any());
- doReturn(null).when(configBackupDeleteInput).getActionIdentifiers();
- results = appcProviderLcm.configBackupDelete(configBackupDeleteInput);
- Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
- == results.get().getResult().getStatus().getCode());
- verify(appcProviderLcm, times(1)).executeRequest(any());
- }
-
- @Test
- public void testConfigExport() throws Exception {
- // Validation success
- doReturn("Success").when(successlcmStatus).getMessage();
- doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
- doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
- doReturn(null).when(validationService).validateInput(any(), any(), any());
+ @Test
+ public void upgradeBackupTest() {
+ UpgradeBackupInput upgradeBackupInput = mock(UpgradeBackupInput.class);
+ Mockito.doReturn(Action.UpgradeBackup).when(upgradeBackupInput).getAction();
+ assertTrue(underTest.upgradeBackup(upgradeBackupInput).isDone());
+ }
- ConfigExportInput configExportInput = mock(ConfigExportInput.class);
- doReturn(newCommonHeader("request-id-aduit")).when(configExportInput).getCommonHeader();
- doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
- .when(configExportInput).getActionIdentifiers();
-
- Future<RpcResult<ConfigExportOutput>> results = appcProviderLcm.configExport
- (configExportInput);
- Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
- Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // Validation failed
- doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
- results = appcProviderLcm.configExport(configExportInput);
- Assert.assertEquals(failStatus, results.get().getResult().getStatus());
- verify(appcProviderLcm, times(1)).executeRequest(any());
-
- // parse exception
- doReturn(null).when(validationService).validateInput(any(), any(), any());
- doReturn(null).when(configExportInput).getActionIdentifiers();
- results = appcProviderLcm.configExport(configExportInput);
- Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
- == results.get().getResult().getStatus().getCode());
- verify(appcProviderLcm, times(1)).executeRequest(any());
- }
-
- @Test
- public void testStopApplication() throws Exception {
- // Validation success
- doReturn("Success").when(successlcmStatus).getMessage();
- doReturn(responseContext).when(requestHandlerOutput).getResponseContext();
- doReturn(requestHandlerOutput).when(appcProviderLcm).executeRequest(any());
- doReturn(null).when(validationService).validateInput(any(), any(), any());
+ @Test
+ public void upgradeBackoutTest() {
+ UpgradeBackoutInput upgradeBackoutInput = mock(UpgradeBackoutInput.class);
+ Mockito.doReturn(Action.UpgradeBackout).when(upgradeBackoutInput).getAction();
+ assertTrue(underTest.upgradeBackout(upgradeBackoutInput).isDone());
+ }
- StopApplicationInput stopApplicationInput = mock(StopApplicationInput.class);
- doReturn(newCommonHeader("request-id-aduit")).when(stopApplicationInput).getCommonHeader();
- doReturn(newActionIdentifier("vnf-id", "vnfc-id", "vserver-id"))
- .when(stopApplicationInput).getActionIdentifiers();
+ @Test
+ public void downloadNESwTest() {
+ DownloadNESwInput downloadNESwInput = mock(DownloadNESwInput.class);
+ Mockito.doReturn(Action.DownloadNESw).when(downloadNESwInput).getAction();
+ assertTrue(underTest.downloadNESw(downloadNESwInput).isDone());
+ }
- Future<RpcResult<StopApplicationOutput>> results = appcProviderLcm.stopApplication
- (stopApplicationInput);
- Assert.assertTrue(400 == results.get().getResult().getStatus().getCode());
- Assert.assertEquals("Success", results.get().getResult().getStatus().getMessage());
- verify(appcProviderLcm, times(1)).executeRequest(any());
+ @Test
+ public void activateNESwTest() {
+ ActivateNESwInput activateNESwInput = mock(ActivateNESwInput.class);
+ Mockito.doReturn(Action.ActivateNESw).when(activateNESwInput).getAction();
+ assertTrue(underTest.activateNESw(activateNESwInput).isDone());
+ }
- // Validation failed
- doReturn(failStatus).when(validationService).validateInput(any(), any(), any());
- results = appcProviderLcm.stopApplication(stopApplicationInput);
- Assert.assertEquals(failStatus, results.get().getResult().getStatus());
- verify(appcProviderLcm, times(1)).executeRequest(any());
+ @Test
+ public void terminateTestParseException() {
+ TerminateInput terminateInput = mock(TerminateInput.class);
+ Mockito.doReturn(Action.Terminate).when(terminateInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(terminateInput).getCommonHeader();
+ assertTrue(underTest.terminate(terminateInput).isDone());
+ }
- // parse exception
- doReturn(null).when(validationService).validateInput(any(), any(), any());
- doReturn(null).when(stopApplicationInput).getActionIdentifiers();
- results = appcProviderLcm.stopApplication(stopApplicationInput);
- Assert.assertTrue(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()
- == results.get().getResult().getStatus().getCode());
- verify(appcProviderLcm, times(1)).executeRequest(any());
+ @Test
+ public void terminateTest() {
+ AppcProviderLcm underTestSpy = Mockito.spy(underTest);
+ TerminateInput terminateInput = mock(TerminateInput.class);
+ Mockito.doReturn(Action.Terminate).when(terminateInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(terminateInput).getCommonHeader();
+ Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(terminateInput).getActionIdentifiers();
+ Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
+ assertTrue(underTestSpy.terminate(terminateInput).isDone());
}
@Test
- public void testQuery() throws Exception {
- QueryInput mockInput = mock(QueryInput.class);
- QueryOutput mockOutput = mock(QueryOutput.class);
- QueryOutputBuilder mockQueryOutputBuilder = mock(QueryOutputBuilder.class);
- QueryService mockQuery = mock(QueryService.class);
+ public void configScaleOutTest() {
+ ConfigScaleOutInput configScaleOutInput = mock(ConfigScaleOutInput.class);
+ Mockito.doReturn(Action.ConfigScaleOut).when(configScaleOutInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(configScaleOutInput)
+ .getCommonHeader();
+ assertTrue(underTest.configScaleOut(configScaleOutInput).isDone());
+ }
- whenNew(QueryService.class).withNoArguments().thenReturn(mockQuery);
- when(mockQuery.process(mockInput)).thenReturn(mockQueryOutputBuilder);
- when(mockQueryOutputBuilder.build()).thenReturn(mockOutput);
+ @Test
+ public void configModifyTestParseException() {
+ ConfigModifyInput configModifyInput = mock(ConfigModifyInput.class);
+ Mockito.doReturn(Action.ConfigModify).when(configModifyInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(configModifyInput)
+ .getCommonHeader();
+ assertTrue(underTest.configModify(configModifyInput).isDone());
+ }
- Future<RpcResult<QueryOutput>> results = appcProviderLcm.query(mockInput);
- verify(mockQuery, times(1)).process(mockInput);
- Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
+ @Test
+ public void configModifyTest() {
+ AppcProviderLcm underTestSpy = Mockito.spy(underTest);
+ ConfigModifyInput configModifyInput = mock(ConfigModifyInput.class);
+ Mockito.doReturn(Action.ConfigModify).when(configModifyInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(configModifyInput).getCommonHeader();
+ Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(configModifyInput).getActionIdentifiers();
+ Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
+ assertTrue(underTestSpy.configModify(configModifyInput).isDone());
}
@Test
- public void testReboot() throws Exception {
- RebootInput mockInput = mock(RebootInput.class);
- RebootOutput mockOutput = mock(RebootOutput.class);
- RebootOutputBuilder mockRebootOutputBuilder = mock(RebootOutputBuilder.class);
- RebootService mockReboot = mock(RebootService.class);
+ public void actionStatusTest() {
+ ActionStatusInput actionStatusInput = mock(ActionStatusInput.class);
+ Mockito.doReturn(Action.ActionStatus).when(actionStatusInput).getAction();
+ assertTrue(underTest.actionStatus(actionStatusInput).isDone());
+ }
- whenNew(RebootService.class).withNoArguments().thenReturn(mockReboot);
- when(mockReboot.process(mockInput)).thenReturn(mockRebootOutputBuilder);
- when(mockRebootOutputBuilder.build()).thenReturn(mockOutput);
+ @Test
+ public void configRestoreTestParseException() {
+ ConfigRestoreInput configRestoreInput = mock(ConfigRestoreInput.class);
+ Mockito.doReturn(Action.ConfigRestore).when(configRestoreInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(configRestoreInput)
+ .getCommonHeader();
+ assertTrue(underTest.configRestore(configRestoreInput).isDone());
+ }
- Future<RpcResult<RebootOutput>> results = appcProviderLcm.reboot(mockInput);
- verify(mockReboot, times(1)).process(mockInput);
- Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
+ @Test
+ public void configRestoreTest() {
+ AppcProviderLcm underTestSpy = Mockito.spy(underTest);
+ ConfigRestoreInput configRestoreInput = mock(ConfigRestoreInput.class);
+ Mockito.doReturn(Action.ConfigRestore).when(configRestoreInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(configRestoreInput).getCommonHeader();
+ Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(configRestoreInput).getActionIdentifiers();
+ Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
+ assertTrue(underTestSpy.configRestore(configRestoreInput).isDone());
}
@Test
- public void testAttachVolume() throws Exception {
- AttachVolumeInput mockInput = mock(AttachVolumeInput.class);
- AttachVolumeOutput mockOutput = mock(AttachVolumeOutput.class);
- AttachVolumeOutputBuilder mockOutputBuilder = mock(AttachVolumeOutputBuilder.class);
- VolumeService mockVolumeService = mock(VolumeService.class);
+ public void configureTestParseException() {
+ ConfigureInput configureInput = mock(ConfigureInput.class);
+ Mockito.doReturn(Action.Configure).when(configureInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(configureInput).getCommonHeader();
+ assertTrue(underTest.configure(configureInput).isDone());
+ }
- whenNew(VolumeService.class).withArguments(true).thenReturn(mockVolumeService);
- when(mockVolumeService.attachVolume(mockInput)).thenReturn(mockOutputBuilder);
- when(mockOutputBuilder.build()).thenReturn(mockOutput);
+ @Test
+ public void configureTest() {
+ AppcProviderLcm underTestSpy = Mockito.spy(underTest);
+ ConfigureInput configureInput = mock(ConfigureInput.class);
+ Mockito.doReturn(Action.Configure).when(configureInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(configureInput).getCommonHeader();
+ Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(configureInput).getActionIdentifiers();
+ Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
+ assertTrue(underTestSpy.configure(configureInput).isDone());
+ }
- Future<RpcResult<AttachVolumeOutput>> results = appcProviderLcm.attachVolume(mockInput);
- verify(mockVolumeService, times(1)).attachVolume(mockInput);
- Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
+ @Test
+ public void testTestParseException() {
+ TestInput testInput = mock(TestInput.class);
+ Mockito.doReturn(Action.Test).when(testInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(testInput).getCommonHeader();
+ assertTrue(underTest.test(testInput).isDone());
}
@Test
- public void testDetachVolume() throws Exception {
- DetachVolumeInput mockInput = mock(DetachVolumeInput.class);
- DetachVolumeOutput mockOutput = mock(DetachVolumeOutput.class);
- DetachVolumeOutputBuilder mockOutputBuilder = mock(DetachVolumeOutputBuilder.class);
- VolumeService mockVolumeService = mock(VolumeService.class);
+ public void testTest() {
+ AppcProviderLcm underTestSpy = Mockito.spy(underTest);
+ TestInput testInput = mock(TestInput.class);
+ Mockito.doReturn(Action.Test).when(testInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(testInput).getCommonHeader();
+ Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(testInput).getActionIdentifiers();
+ Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
+ assertTrue(underTestSpy.test(testInput).isDone());
+ }
- whenNew(VolumeService.class).withArguments(false).thenReturn(mockVolumeService);
- when(mockVolumeService.detachVolume(mockInput)).thenReturn(mockOutputBuilder);
- when(mockOutputBuilder.build()).thenReturn(mockOutput);
+ @Test
+ public void stopTestParseException() {
+ StopInput stopInput = mock(StopInput.class);
+ Mockito.doReturn(Action.Stop).when(stopInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(stopInput).getCommonHeader();
+ assertTrue(underTest.stop(stopInput).isDone());
+ }
- Future<RpcResult<DetachVolumeOutput>> results = appcProviderLcm.detachVolume(mockInput);
- verify(mockVolumeService, times(1)).detachVolume(mockInput);
- Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
+ @Test
+ public void stopTest() {
+ AppcProviderLcm underTestSpy = Mockito.spy(underTest);
+ StopInput stopInput = mock(StopInput.class);
+ Mockito.doReturn(Action.Stop).when(stopInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(stopInput).getCommonHeader();
+ Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(stopInput).getActionIdentifiers();
+ Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
+ assertTrue(underTestSpy.stop(stopInput).isDone());
}
@Test
- public void testQuiesceTraffic() throws Exception {
- QuiesceTrafficInput mockInput = mock(QuiesceTrafficInput.class);
- QuiesceTrafficOutput mockOutput = mock(QuiesceTrafficOutput.class);
- QuiesceTrafficOutputBuilder mockOutputBuilder = mock(QuiesceTrafficOutputBuilder.class);
- QuiesceTrafficService mockService = mock(QuiesceTrafficService.class);
+ public void startTestParseException() {
+ StartInput startInput = mock(StartInput.class);
+ Mockito.doReturn(Action.Start).when(startInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(startInput).getCommonHeader();
+ assertTrue(underTest.start(startInput).isDone());
+ }
- whenNew(QuiesceTrafficService.class).withNoArguments().thenReturn(mockService);
- when(mockService.process(mockInput)).thenReturn(mockOutputBuilder);
- when(mockOutputBuilder.build()).thenReturn(mockOutput);
+ @Test
+ public void startTest() {
+ AppcProviderLcm underTestSpy = Mockito.spy(underTest);
+ StartInput startInput = mock(StartInput.class);
+ Mockito.doReturn(Action.Rebuild).when(startInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(startInput).getCommonHeader();
+ Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(startInput).getActionIdentifiers();
+ Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
+ assertTrue(underTestSpy.start(startInput).isDone());
+ }
- Future<RpcResult<QuiesceTrafficOutput>> results = appcProviderLcm.quiesceTraffic(mockInput);
- verify(mockService, times(1)).process(mockInput);
- Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
+ @Test
+ public void auditTestParseExcpetion() {
+ AuditInput auditInput = mock(AuditInput.class);
+ Mockito.doReturn(Action.Audit).when(auditInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(auditInput).getCommonHeader();
+ assertTrue(underTest.audit(auditInput).isDone());
}
@Test
- public void testResumeTraffic() throws Exception {
- ResumeTrafficInput mockInput = mock(ResumeTrafficInput.class);
- ResumeTrafficOutput mockOutput = mock(ResumeTrafficOutput.class);
- ResumeTrafficOutputBuilder mockOutputBuilder = mock(ResumeTrafficOutputBuilder.class);
- ResumeTrafficService mockService = mock(ResumeTrafficService.class);
+ public void auditTest() {
+ AppcProviderLcm underTestSpy = Mockito.spy(underTest);
+ AuditInput auditInput = mock(AuditInput.class);
+ Mockito.doReturn(Action.Audit).when(auditInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(auditInput).getCommonHeader();
+ Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(auditInput).getActionIdentifiers();
+ Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
+ assertTrue(underTestSpy.audit(auditInput).isDone());
+ }
- whenNew(ResumeTrafficService.class).withNoArguments().thenReturn(mockService);
- when(mockService.process(mockInput)).thenReturn(mockOutputBuilder);
- when(mockOutputBuilder.build()).thenReturn(mockOutput);
+ @Test
+ public void softwareUploadTestParseException() {
+ SoftwareUploadInput softwareUploadInput = mock(SoftwareUploadInput.class);
+ Mockito.doReturn(Action.SoftwareUpload).when(softwareUploadInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(softwareUploadInput)
+ .getCommonHeader();
+ assertTrue(underTest.softwareUpload(softwareUploadInput).isDone());
+ }
- Future<RpcResult<ResumeTrafficOutput>> results = appcProviderLcm.resumeTraffic(mockInput);
- verify(mockService, times(1)).process(mockInput);
- Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
+ @Test
+ public void softwareUploadTest() {
+ AppcProviderLcm underTestSpy = Mockito.spy(underTest);
+ SoftwareUploadInput softwareUploadInput = mock(SoftwareUploadInput.class);
+ Mockito.doReturn(Action.SoftwareUpload).when(softwareUploadInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(softwareUploadInput).getCommonHeader();
+ Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(softwareUploadInput).getActionIdentifiers();
+ Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
+ assertTrue(underTestSpy.softwareUpload(softwareUploadInput).isDone());
}
@Test
- public void testUpgradePreCheck() throws Exception {
- UpgradePreCheckInput mockInput = mock(UpgradePreCheckInput.class);
- UpgradePreCheckOutput mockOutput = mock(UpgradePreCheckOutput.class);
- UpgradePreCheckOutputBuilder mockOutputBuilder = mock(UpgradePreCheckOutputBuilder.class);
- UpgradeService mockService = mock(UpgradeService.class);
+ public void healthCheckTestParseException() {
+ HealthCheckInput healthCheckInput = mock(HealthCheckInput.class);
+ Mockito.doReturn(Action.HealthCheck).when(healthCheckInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(healthCheckInput).getCommonHeader();
+ assertTrue(underTest.healthCheck(healthCheckInput).isDone());
+ }
- whenNew(UpgradeService.class).withAnyArguments().thenReturn(mockService);
- when(mockService.upgradePreCheck(mockInput)).thenReturn(mockOutputBuilder);
- when(mockOutputBuilder.build()).thenReturn(mockOutput);
+ @Test
+ public void healthCheckTest() {
+ AppcProviderLcm underTestSpy = Mockito.spy(underTest);
+ HealthCheckInput healthCheckInput = mock(HealthCheckInput.class);
+ Mockito.doReturn(Action.HealthCheck).when(healthCheckInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(healthCheckInput).getCommonHeader();
+ Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(healthCheckInput).getActionIdentifiers();
+ Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
+ assertTrue(underTestSpy.healthCheck(healthCheckInput).isDone());
+ }
- Future<RpcResult<UpgradePreCheckOutput>> results = appcProviderLcm.upgradePreCheck(mockInput);
- verify(mockService, times(1)).upgradePreCheck(mockInput);
- Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
+ @Test
+ public void liveUpgradeTestParseException() {
+ LiveUpgradeInput liveUpgradeInput = mock(LiveUpgradeInput.class);
+ Mockito.doReturn(Action.LiveUpgrade).when(liveUpgradeInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(liveUpgradeInput).getCommonHeader();
+ assertTrue(underTest.liveUpgrade(liveUpgradeInput).isDone());
}
+ @Test
+ public void liveUpgradeTest() {
+ AppcProviderLcm underTestSpy = Mockito.spy(underTest);
+ LiveUpgradeInput liveUpgradeInput = mock(LiveUpgradeInput.class);
+ Mockito.doReturn(Action.LiveUpgrade).when(liveUpgradeInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(liveUpgradeInput).getCommonHeader();
+ Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(liveUpgradeInput).getActionIdentifiers();
+ Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
+ assertTrue(underTestSpy.liveUpgrade(liveUpgradeInput).isDone());
+ }
@Test
- public void testUpgradePostCheck() throws Exception {
- UpgradePostCheckInput mockInput = mock(UpgradePostCheckInput.class);
- UpgradePostCheckOutput mockOutput = mock(UpgradePostCheckOutput.class);
- UpgradePostCheckOutputBuilder mockOutputBuilder = mock(UpgradePostCheckOutputBuilder.class);
- UpgradeService mockService = mock(UpgradeService.class);
+ public void lockTestParseException() {
+ LockInput lockInput = mock(LockInput.class);
+ Mockito.doReturn(Action.Lock).when(lockInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(lockInput).getCommonHeader();
+ assertTrue(underTest.lock(lockInput).isDone());
+ }
- whenNew(UpgradeService.class).withAnyArguments().thenReturn(mockService);
- when(mockService.upgradePostCheck(mockInput)).thenReturn(mockOutputBuilder);
- when(mockOutputBuilder.build()).thenReturn(mockOutput);
+ @Test
+ public void lockTest() {
+ AppcProviderLcm underTestSpy = Mockito.spy(underTest);
+ LockInput lockInput = mock(LockInput.class);
+ Mockito.doReturn(Action.LiveUpgrade).when(lockInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(lockInput).getCommonHeader();
+ Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(lockInput).getActionIdentifiers();
+ Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
+ assertTrue(underTestSpy.lock(lockInput).isDone());
+ }
- Future<RpcResult<UpgradePostCheckOutput>> results = appcProviderLcm.upgradePostCheck(mockInput);
- verify(mockService, times(1)).upgradePostCheck(mockInput);
- Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
+ @Test
+ public void unlockTestParseException() {
+ UnlockInput unlockInput = mock(UnlockInput.class);
+ Mockito.doReturn(Action.Unlock).when(unlockInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(unlockInput).getCommonHeader();
+ assertTrue(underTest.unlock(unlockInput).isDone());
}
@Test
- public void testUpgradeSoftware() throws Exception {
- UpgradeSoftwareInput mockInput = mock(UpgradeSoftwareInput.class);
- UpgradeSoftwareOutput mockOutput = mock(UpgradeSoftwareOutput.class);
- UpgradeSoftwareOutputBuilder mockOutputBuilder = mock(UpgradeSoftwareOutputBuilder.class);
- UpgradeService mockService = mock(UpgradeService.class);
+ public void unLockTest() {
+ AppcProviderLcm underTestSpy = Mockito.spy(underTest);
+ UnlockInput unlockInput = mock(UnlockInput.class);
+ Mockito.doReturn(Action.Unlock).when(unlockInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(unlockInput).getCommonHeader();
+ Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(unlockInput).getActionIdentifiers();
+ Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
+ assertTrue(underTestSpy.unlock(unlockInput).isDone());
+ }
- whenNew(UpgradeService.class).withAnyArguments().thenReturn(mockService);
- when(mockService.upgradeSoftware(mockInput)).thenReturn(mockOutputBuilder);
- when(mockOutputBuilder.build()).thenReturn(mockOutput);
+ @Test
+ public void checkLockTestParseException() {
+ CheckLockInput checkLockInput = mock(CheckLockInput.class);
+ Mockito.doReturn(Action.CheckLock).when(checkLockInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(checkLockInput).getCommonHeader();
+ assertTrue(underTest.checkLock(checkLockInput).isDone());
+ }
- Future<RpcResult<UpgradeSoftwareOutput>> results = appcProviderLcm.upgradeSoftware(mockInput);
- verify(mockService, times(1)).upgradeSoftware(mockInput);
- Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
+ @Test
+ public void checkLockTest() {
+ AppcProviderLcm underTestSpy = Mockito.spy(underTest);
+ CheckLockInput checkLockInput = mock(CheckLockInput.class);
+ Mockito.doReturn(Action.CheckLock).when(checkLockInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(checkLockInput).getCommonHeader();
+ Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(checkLockInput).getActionIdentifiers();
+ RequestHandlerOutput output = Mockito.mock(RequestHandlerOutput.class);
+ ResponseContext responseContext = Mockito.mock(ResponseContext.class);
+ Status status = Mockito.mock(Status.class);
+ Map<String, String> additionalContext = new HashMap<>();
+ additionalContext.put("locked", "true");
+ Mockito.doReturn(additionalContext).when(responseContext).getAdditionalContext();
+ Mockito.doReturn(400).when(status).getCode();
+ Mockito.doReturn(status).when(responseContext).getStatus();
+ Mockito.doReturn(responseContext).when(output).getResponseContext();
+ Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
+ assertTrue(underTestSpy.checkLock(checkLockInput).isDone());
}
@Test
- public void testUpgradeBackup() throws Exception {
- UpgradeBackupInput mockInput = mock(UpgradeBackupInput.class);
- UpgradeBackupOutput mockOutput = mock(UpgradeBackupOutput.class);
- UpgradeBackupOutputBuilder mockOutputBuilder = mock(UpgradeBackupOutputBuilder.class);
- UpgradeService mockService = mock(UpgradeService.class);
+ public void configBackupTestParseException() {
+ ConfigBackupInput configBackupInput = mock(ConfigBackupInput.class);
+ Mockito.doReturn(Action.ConfigBackup).when(configBackupInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(configBackupInput)
+ .getCommonHeader();
+ assertTrue(underTest.configBackup(configBackupInput).isDone());
+ }
- whenNew(UpgradeService.class).withAnyArguments().thenReturn(mockService);
- when(mockService.upgradeBackup(mockInput)).thenReturn(mockOutputBuilder);
- when(mockOutputBuilder.build()).thenReturn(mockOutput);
+ @Test
+ public void configBackupTest() {
+ AppcProviderLcm underTestSpy = Mockito.spy(underTest);
+ ConfigBackupInput configBackupInput = mock(ConfigBackupInput.class);
+ Mockito.doReturn(Action.ConfigBackup).when(configBackupInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(configBackupInput).getCommonHeader();
+ Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(configBackupInput).getActionIdentifiers();
+ Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
+ assertTrue(underTestSpy.configBackup(configBackupInput).isDone());
+ }
- Future<RpcResult<UpgradeBackupOutput>> results = appcProviderLcm.upgradeBackup(mockInput);
- verify(mockService, times(1)).upgradeBackup(mockInput);
- Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
+ @Test
+ public void configBackupDeleteTestParseException() {
+ ConfigBackupDeleteInput configBackupDeleteInput = mock(ConfigBackupDeleteInput.class);
+ Mockito.doReturn(Action.ConfigBackupDelete).when(configBackupDeleteInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(configBackupDeleteInput)
+ .getCommonHeader();
+ assertTrue(underTest.configBackupDelete(configBackupDeleteInput).isDone());
}
@Test
- public void testUpgradeBackout() throws Exception {
- UpgradeBackoutInput mockInput = mock(UpgradeBackoutInput.class);
- UpgradeBackoutOutput mockOutput = mock(UpgradeBackoutOutput.class);
- UpgradeBackoutOutputBuilder mockOutputBuilder = mock(UpgradeBackoutOutputBuilder.class);
- UpgradeService mockService = mock(UpgradeService.class);
+ public void configBackupDeleteTest() {
+ AppcProviderLcm underTestSpy = Mockito.spy(underTest);
+ ConfigBackupDeleteInput configBackupDeleteInput = mock(ConfigBackupDeleteInput.class);
+ Mockito.doReturn(Action.ConfigBackupDelete).when(configBackupDeleteInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(configBackupDeleteInput).getCommonHeader();
+ Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(configBackupDeleteInput).getActionIdentifiers();
+ Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
+ assertTrue(underTestSpy.configBackupDelete(configBackupDeleteInput).isDone());
+ }
- whenNew(UpgradeService.class).withAnyArguments().thenReturn(mockService);
- when(mockService.upgradeBackout(mockInput)).thenReturn(mockOutputBuilder);
- when(mockOutputBuilder.build()).thenReturn(mockOutput);
+ @Test
+ public void configExportTestParseException() {
+ ConfigExportInput configExportInput = mock(ConfigExportInput.class);
+ Mockito.doReturn(Action.ConfigExport).when(configExportInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(configExportInput)
+ .getCommonHeader();
+ assertTrue(underTest.configExport(configExportInput).isDone());
+ }
- Future<RpcResult<UpgradeBackoutOutput>> results = appcProviderLcm.upgradeBackout(mockInput);
- verify(mockService, times(1)).upgradeBackout(mockInput);
- Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
+ @Test
+ public void configExportTest() {
+ AppcProviderLcm underTestSpy = Mockito.spy(underTest);
+ ConfigExportInput configExportInput = mock(ConfigExportInput.class);
+ Mockito.doReturn(Action.ConfigExport).when(configExportInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(configExportInput).getCommonHeader();
+ Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(configExportInput).getActionIdentifiers();
+ Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
+ assertTrue(underTestSpy.configExport(configExportInput).isDone());
}
- @After
- public void tearDown() throws Exception {
- if (appcProviderLcm != null) {
- appcProviderLcm.close();
- }
+ @Test
+ public void stopApplicationTestParseException() {
+ StopApplicationInput stopApplicationInput = mock(StopApplicationInput.class);
+ Mockito.doReturn(Action.StopApplication).when(stopApplicationInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(stopApplicationInput)
+ .getCommonHeader();
+ assertTrue(underTest.stopApplication(stopApplicationInput).isDone());
}
+ @Test
+ public void stopApplicationTest() {
+ AppcProviderLcm underTestSpy = Mockito.spy(underTest);
+ StopApplicationInput stopApplicationInput = mock(StopApplicationInput.class);
+ Mockito.doReturn(Action.StopApplication).when(stopApplicationInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(stopApplicationInput).getCommonHeader();
+ Mockito.doReturn(new ActionIdentifiersBuilder().build()).when(stopApplicationInput).getActionIdentifiers();
+ Mockito.doReturn(output).when(underTestSpy).executeRequest(Mockito.any(RequestHandlerInput.class));
+ assertTrue(underTestSpy.stopApplication(stopApplicationInput).isDone());
+ }
- private ActionIdentifiers newActionIdentifier(String vnfId, String vnfcId, String vserverId) {
- ActionIdentifiersBuilder actionIdentifiersBuilder = new ActionIdentifiersBuilder();
- actionIdentifiersBuilder.setVnfId(vnfId);
- actionIdentifiersBuilder.setVnfcName(vnfcId);
- actionIdentifiersBuilder.setVserverId(vserverId);
- return actionIdentifiersBuilder.build();
+ @Test
+ public void closeTest() throws Exception {
+ underTest.close();
+ Mockito.verify(rpcRegistration).close();
+ }
+
+ @Test
+ public void configScaleInTest() {
+ ConfigScaleInInput configScaleInInput = mock(ConfigScaleInInput.class);
+ Mockito.doReturn(Action.ConfigScaleIn).when(configScaleInInput).getAction();
+ Mockito.doReturn(getCommonHeaderBuilder().build()).when(configScaleInInput)
+ .getCommonHeader();
+ assertTrue(underTest.configScaleIn(configScaleInInput).isDone());
}
- private CommonHeader newCommonHeader(String requestId) {
- CommonHeaderBuilder commonHeaderBuilder = new CommonHeaderBuilder();
- commonHeaderBuilder.setRequestId(requestId);
- commonHeaderBuilder.setApiVer("2.0.0");
- commonHeaderBuilder.setOriginatorId("originatortest");
- commonHeaderBuilder.setTimestamp(ZULU.getDefaultInstance(LocalDateTime.now(Clock.systemUTC()).toString() +
- "Z"));
- return commonHeaderBuilder.build();
+ private CommonHeaderBuilder getCommonHeaderBuilder() {
+ CommonHeaderBuilder headerBuilder = new CommonHeaderBuilder();
+ headerBuilder.setApiVer("API-VERSION");
+ headerBuilder.setTimestamp(ZULU.getDefaultInstance("1970-01-01T00:00:00.000Z"));
+ headerBuilder.setOriginatorId("ORIGINATOR-ID");
+ headerBuilder.setRequestId("REQUEST-ID");
+ return headerBuilder;
}
}