Include impacted changes for APPC-346,APPC-348

Issue-ID: APPC-347
Change-Id: I399bc2a1e0dfd481e103032a373bb80fce5baf41
Signed-off-by: Anand <ac204h@att.com>

12 files changed, 2856 insertions, 5 deletions

diff --git a/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/AppcProviderLcmTest.java b/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/AppcProviderLcmTest.java
index f25df9c44..064f5679f 100644
--- a/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/AppcProviderLcmTest.java
+++ b/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/AppcProviderLcmTest.java
@@ -9,15 +9,15 @@
  * 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
- *
+ * 
  *      http://www.apache.org/licenses/LICENSE-2.0
- *
+ * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * 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=========================================================
  */
@@ -36,6 +36,9 @@ import org.opendaylight.controller.md.sal.binding.test.AbstractDataBrokerTest;
 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
 import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+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;
@@ -54,6 +57,9 @@ import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigScaleoutIn
 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ConfigScaleoutOutput;
 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.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;
@@ -64,6 +70,33 @@ 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;
@@ -100,6 +133,7 @@ import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.status.StatusBui
 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;
@@ -122,13 +156,16 @@ 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, ValidationService.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();
@@ -1091,6 +1128,183 @@ public class AppcProviderLcmTest extends AbstractDataBrokerTest {
         verify(appcProviderLcm, times(1)).executeRequest(any());
     }
 
+    @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);
+
+        whenNew(QueryService.class).withNoArguments().thenReturn(mockQuery);
+        when(mockQuery.process(mockInput)).thenReturn(mockQueryOutputBuilder);
+        when(mockQueryOutputBuilder.build()).thenReturn(mockOutput);
+
+        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 testReboot() throws Exception {
+        RebootInput mockInput = mock(RebootInput.class);
+        RebootOutput mockOutput = mock(RebootOutput.class);
+        RebootOutputBuilder mockRebootOutputBuilder = mock(RebootOutputBuilder.class);
+        RebootService mockReboot = mock(RebootService.class);
+
+        whenNew(RebootService.class).withNoArguments().thenReturn(mockReboot);
+        when(mockReboot.process(mockInput)).thenReturn(mockRebootOutputBuilder);
+        when(mockRebootOutputBuilder.build()).thenReturn(mockOutput);
+
+        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 testAttachVolume() throws Exception {
+        AttachVolumeInput mockInput = mock(AttachVolumeInput.class);
+        AttachVolumeOutput mockOutput = mock(AttachVolumeOutput.class);
+        AttachVolumeOutputBuilder mockOutputBuilder = mock(AttachVolumeOutputBuilder.class);
+        VolumeService mockVolumeService = mock(VolumeService.class);
+
+        whenNew(VolumeService.class).withArguments(true).thenReturn(mockVolumeService);
+        when(mockVolumeService.attachVolume(mockInput)).thenReturn(mockOutputBuilder);
+        when(mockOutputBuilder.build()).thenReturn(mockOutput);
+
+        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 testDetachVolume() throws Exception {
+        DetachVolumeInput mockInput = mock(DetachVolumeInput.class);
+        DetachVolumeOutput mockOutput = mock(DetachVolumeOutput.class);
+        DetachVolumeOutputBuilder mockOutputBuilder = mock(DetachVolumeOutputBuilder.class);
+        VolumeService mockVolumeService = mock(VolumeService.class);
+
+        whenNew(VolumeService.class).withArguments(false).thenReturn(mockVolumeService);
+        when(mockVolumeService.detachVolume(mockInput)).thenReturn(mockOutputBuilder);
+        when(mockOutputBuilder.build()).thenReturn(mockOutput);
+
+        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 testQuiesceTraffic() throws Exception {
+        QuiesceTrafficInput mockInput = mock(QuiesceTrafficInput.class);
+        QuiesceTrafficOutput mockOutput = mock(QuiesceTrafficOutput.class);
+        QuiesceTrafficOutputBuilder mockOutputBuilder = mock(QuiesceTrafficOutputBuilder.class);
+        QuiesceTrafficService mockService = mock(QuiesceTrafficService.class);
+
+        whenNew(QuiesceTrafficService.class).withNoArguments().thenReturn(mockService);
+        when(mockService.process(mockInput)).thenReturn(mockOutputBuilder);
+        when(mockOutputBuilder.build()).thenReturn(mockOutput);
+
+        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 testResumeTraffic() throws Exception {
+        ResumeTrafficInput mockInput = mock(ResumeTrafficInput.class);
+        ResumeTrafficOutput mockOutput = mock(ResumeTrafficOutput.class);
+        ResumeTrafficOutputBuilder mockOutputBuilder = mock(ResumeTrafficOutputBuilder.class);
+        ResumeTrafficService mockService = mock(ResumeTrafficService.class);
+
+        whenNew(ResumeTrafficService.class).withNoArguments().thenReturn(mockService);
+        when(mockService.process(mockInput)).thenReturn(mockOutputBuilder);
+        when(mockOutputBuilder.build()).thenReturn(mockOutput);
+
+        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 testUpgradePreCheck() throws Exception {
+        UpgradePreCheckInput mockInput = mock(UpgradePreCheckInput.class);
+        UpgradePreCheckOutput mockOutput = mock(UpgradePreCheckOutput.class);
+        UpgradePreCheckOutputBuilder mockOutputBuilder = mock(UpgradePreCheckOutputBuilder.class);
+        UpgradeService mockService = mock(UpgradeService.class);
+
+        whenNew(UpgradeService.class).withAnyArguments().thenReturn(mockService);
+        when(mockService.upgradePreCheck(mockInput)).thenReturn(mockOutputBuilder);
+        when(mockOutputBuilder.build()).thenReturn(mockOutput);
+
+        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 testUpgradePostCheck() throws Exception {
+        UpgradePostCheckInput mockInput = mock(UpgradePostCheckInput.class);
+        UpgradePostCheckOutput mockOutput = mock(UpgradePostCheckOutput.class);
+        UpgradePostCheckOutputBuilder mockOutputBuilder = mock(UpgradePostCheckOutputBuilder.class);
+        UpgradeService mockService = mock(UpgradeService.class);
+
+        whenNew(UpgradeService.class).withAnyArguments().thenReturn(mockService);
+        when(mockService.upgradePostCheck(mockInput)).thenReturn(mockOutputBuilder);
+        when(mockOutputBuilder.build()).thenReturn(mockOutput);
+
+        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 testUpgradeSoftware() throws Exception {
+        UpgradeSoftwareInput mockInput = mock(UpgradeSoftwareInput.class);
+        UpgradeSoftwareOutput mockOutput = mock(UpgradeSoftwareOutput.class);
+        UpgradeSoftwareOutputBuilder mockOutputBuilder = mock(UpgradeSoftwareOutputBuilder.class);
+        UpgradeService mockService = mock(UpgradeService.class);
+
+        whenNew(UpgradeService.class).withAnyArguments().thenReturn(mockService);
+        when(mockService.upgradeSoftware(mockInput)).thenReturn(mockOutputBuilder);
+        when(mockOutputBuilder.build()).thenReturn(mockOutput);
+
+        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 testUpgradeBackup() throws Exception {
+        UpgradeBackupInput mockInput = mock(UpgradeBackupInput.class);
+        UpgradeBackupOutput mockOutput = mock(UpgradeBackupOutput.class);
+        UpgradeBackupOutputBuilder mockOutputBuilder = mock(UpgradeBackupOutputBuilder.class);
+        UpgradeService mockService = mock(UpgradeService.class);
+
+        whenNew(UpgradeService.class).withAnyArguments().thenReturn(mockService);
+        when(mockService.upgradeBackup(mockInput)).thenReturn(mockOutputBuilder);
+        when(mockOutputBuilder.build()).thenReturn(mockOutput);
+
+        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 testUpgradeBackout() throws Exception {
+        UpgradeBackoutInput mockInput = mock(UpgradeBackoutInput.class);
+        UpgradeBackoutOutput mockOutput = mock(UpgradeBackoutOutput.class);
+        UpgradeBackoutOutputBuilder mockOutputBuilder = mock(UpgradeBackoutOutputBuilder.class);
+        UpgradeService mockService = mock(UpgradeService.class);
+
+        whenNew(UpgradeService.class).withAnyArguments().thenReturn(mockService);
+        when(mockService.upgradeBackout(mockInput)).thenReturn(mockOutputBuilder);
+        when(mockOutputBuilder.build()).thenReturn(mockOutput);
+
+        Future<RpcResult<UpgradeBackoutOutput>> results = appcProviderLcm.upgradeBackout(mockInput);
+        verify(mockService, times(1)).upgradeBackout(mockInput);
+        Assert.assertEquals("Should return mockOutput", mockOutput, results.get().getResult());
+    }
+
     @After
     public void tearDown() throws Exception {
         if (appcProviderLcm != null) {
@@ -1098,6 +1312,7 @@ public class AppcProviderLcmTest extends AbstractDataBrokerTest {
         }
     }
 
+
     private ActionIdentifiers newActionIdentifier(String vnfId, String vnfcId, String vserverId) {
         ActionIdentifiersBuilder actionIdentifiersBuilder = new ActionIdentifiersBuilder();
         actionIdentifiersBuilder.setVnfId(vnfId);
@@ -1115,4 +1330,4 @@ public class AppcProviderLcmTest extends AbstractDataBrokerTest {
             "Z"));
         return commonHeaderBuilder.build();
     }
-}
\ No newline at end of file
+}
diff --git a/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/service/AbstractBaseServiceTest.java b/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/service/AbstractBaseServiceTest.java
new file mode 100644
index 000000000..012b840bb
--- /dev/null
+++ b/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/service/AbstractBaseServiceTest.java
@@ -0,0 +1,212 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * ONAP : APPC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * 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
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * 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.lcm.service;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.Action;
+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.common.header.CommonHeader;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.status.Status;
+import org.onap.appc.executor.objects.LCMCommandStatus;
+import org.onap.appc.executor.objects.Params;
+import org.onap.appc.requesthandler.objects.RequestHandlerOutput;
+import org.powermock.reflect.Whitebox;
+
+import java.util.EnumSet;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+
+public class AbstractBaseServiceTest {
+    private Action expectedAction = Action.Query;
+    private String rpcName = expectedAction.name().toLowerCase();
+
+    private CommonHeader commonHeader = mock(CommonHeader.class);
+    private ActionIdentifiers mockAI = mock(ActionIdentifiers.class);
+    private testAbc testAbstractBaseService;
+
+    class testAbc extends AbstractBaseService {
+        public testAbc() {
+            super(AbstractBaseServiceTest.this.expectedAction);
+        }
+    }
+
+    @Before
+    public void setUp() throws Exception {
+        testAbstractBaseService = spy(new testAbc());
+    }
+
+    @Test
+    public void testConstructor() throws Exception {
+        Assert.assertEquals("Should have proper ACTION", expectedAction,
+            (Action) Whitebox.getInternalState(testAbstractBaseService, "expectedAction"));
+        Assert.assertEquals("Should have action-status RPC name", rpcName,
+            (Whitebox.getInternalState(testAbstractBaseService, "rpcName")).toString());
+    }
+
+    @Test
+    public void testValidateInput() throws Exception {
+        // test commonHeader error
+        Status status = testAbstractBaseService.validateInput(commonHeader, Action.Query, null);
+        Assert.assertEquals("should return missing parameter",
+            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
+
+        ZULU mockTimeStamp = mock(ZULU.class);
+        Mockito.doReturn(mockTimeStamp).when(commonHeader).getTimestamp();
+        Mockito.doReturn("api ver").when(commonHeader).getApiVer();
+        Mockito.doReturn("originator Id").when(commonHeader).getOriginatorId();
+        Mockito.doReturn("request Id").when(commonHeader).getRequestId();
+
+        // test invalid action
+        status = testAbstractBaseService.validateInput(commonHeader, Action.AttachVolume, null);
+        Assert.assertEquals("Should return invalid parameter for action",
+            Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());
+
+        // test null actionIdentifier
+        status = testAbstractBaseService.validateInput(commonHeader, Action.Query, null);
+        Assert.assertEquals("should return missing parameter",
+            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
+
+        // test validation passed
+        status = testAbstractBaseService.validateInput(commonHeader, Action.Query, mockAI);
+        Assert.assertTrue("Should have null status", status == null);
+    }
+
+    @Test
+    public void testValidateVnfId() throws Exception {
+        // Skip test input validation, as it is all done in testValidateInput
+
+        ZULU mockTimeStamp = mock(ZULU.class);
+        Mockito.doReturn(mockTimeStamp).when(commonHeader).getTimestamp();
+        Mockito.doReturn("api ver").when(commonHeader).getApiVer();
+        Mockito.doReturn("originator Id").when(commonHeader).getOriginatorId();
+        Mockito.doReturn("request Id").when(commonHeader).getRequestId();
+
+        // test null VNF ID
+        Status status = testAbstractBaseService.validateVnfId(commonHeader, Action.Query, mockAI);
+        Assert.assertEquals("should return invalid parameter",
+            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
+
+        // test empty VNF_ID
+        Mockito.doReturn("").when(mockAI).getVnfId();
+        status = testAbstractBaseService.validateVnfId(commonHeader, Action.Query, mockAI);
+        Assert.assertEquals("should return invalid parameter",
+            Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());
+
+        // test calling validateExcludeActId
+        Mockito.doReturn("vnfId").when(mockAI).getVnfId();
+        status = testAbstractBaseService.validateVnfId(commonHeader, Action.Query, mockAI);
+        Assert.assertTrue("Should have null status", status == null);
+    }
+
+    @Test
+    public void testValidateVserverId() throws Exception {
+        // Skip test input validation, as it is all done in testValidateInput
+
+        ZULU mockTimeStamp = mock(ZULU.class);
+        Mockito.doReturn(mockTimeStamp).when(commonHeader).getTimestamp();
+        Mockito.doReturn("api ver").when(commonHeader).getApiVer();
+        Mockito.doReturn("originator Id").when(commonHeader).getOriginatorId();
+        Mockito.doReturn("request Id").when(commonHeader).getRequestId();
+
+        // test null VNF ID
+        Status status = testAbstractBaseService.validateVserverId(commonHeader, Action.Query, mockAI);
+        Assert.assertEquals("should return invalid parameter",
+            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
+
+        // test empty VNF_ID
+        Mockito.doReturn("").when(mockAI).getVserverId();
+        status = testAbstractBaseService.validateVserverId(commonHeader, Action.Query, mockAI);
+        Assert.assertEquals("should return invalid parameter",
+            Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());
+
+        // test calling validateExcludeActId
+        Mockito.doReturn("vserverId").when(mockAI).getVserverId();
+        status = testAbstractBaseService.validateVserverId(commonHeader, Action.Query, mockAI);
+        Assert.assertTrue("Should have null status", status == null);
+    }
+
+    @Test
+    public void testValidateExcludedActIds() throws Exception {
+        EnumSet<AbstractBaseService.ACTID_KEYS> exclutionKeys = EnumSet.of(AbstractBaseService.ACTID_KEYS.VNF_ID);
+        Status status = testAbstractBaseService.validateExcludedActIds(mockAI, exclutionKeys);
+        Assert.assertTrue("Should have not error", status  == null);
+
+        Integer expectedErrorCode = Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode());
+        Mockito.doReturn("vnfc name").when(mockAI).getVnfcName();
+        status = testAbstractBaseService.validateExcludedActIds(mockAI, exclutionKeys);
+        Assert.assertEquals("Should have error for vnfc name", expectedErrorCode, status.getCode());
+
+        Mockito.doReturn(null).when(mockAI).getVnfcName();
+        Mockito.doReturn("vserver Id").when(mockAI).getVserverId();
+        status = testAbstractBaseService.validateExcludedActIds(mockAI, exclutionKeys);
+        Assert.assertEquals("Should have error for vserver Id", expectedErrorCode, status.getCode());
+
+        Mockito.doReturn(null).when(mockAI).getVserverId();
+        Mockito.doReturn("vf module Id").when(mockAI).getVfModuleId();
+        status = testAbstractBaseService.validateExcludedActIds(mockAI, exclutionKeys);
+        Assert.assertEquals("Should have error for vf module Id", expectedErrorCode, status.getCode());
+
+        Mockito.doReturn(null).when(mockAI).getServiceInstanceId();
+        Mockito.doReturn("service instance Id").when(mockAI).getServiceInstanceId();
+        status = testAbstractBaseService.validateExcludedActIds(mockAI, exclutionKeys);
+        Assert.assertEquals("Should have error for service instance Id", expectedErrorCode, status.getCode());
+
+        Mockito.doReturn("vnfc name").when(mockAI).getVnfcName();
+        Mockito.doReturn("vserver Id").when(mockAI).getVserverId();
+        Mockito.doReturn("vf module Id").when(mockAI).getVfModuleId();
+        Mockito.doReturn("vnf Id").when(mockAI).getVnfId();
+        status = testAbstractBaseService.validateExcludedActIds(mockAI, exclutionKeys);
+        Assert.assertEquals("Should have error code", expectedErrorCode, status.getCode());
+        Assert.assertEquals("Should have error message",
+            LCMCommandStatus.INVALID_INPUT_PARAMETER.getFormattedMessage(getMsgParams(exclutionKeys)),
+            status.getMessage());
+    }
+
+    @Test
+    public void testExecuteAction() throws Exception {
+        RequestHandlerOutput output = testAbstractBaseService.executeAction(null);
+        Assert.assertTrue("Should return null RequestHandlerOutput", output == null);
+        Status status = Whitebox.getInternalState(testAbstractBaseService, "status");
+        Assert.assertEquals("Should have error code",
+            Integer.valueOf(LCMCommandStatus.UNEXPECTED_ERROR.getResponseCode()), status.getCode());
+    }
+
+    private Params getMsgParams(EnumSet<AbstractBaseService.ACTID_KEYS> exclutionKeys) {
+        StringBuilder msgBuilder = new StringBuilder();
+        for (QueryService.ACTID_KEYS aKey : AbstractBaseService.ACTID_KEYS.values()) {
+            if (exclutionKeys.contains(aKey)) {
+                continue;
+            }
+            msgBuilder.append(aKey.getKeyName()).append(testAbstractBaseService.DELIMITER_COMMA);
+        }
+        String msg = msgBuilder.toString();
+        return new Params().addParam("errorMsg", msg.substring(0, msg.length() -1));
+    }
+}
diff --git a/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/service/AbstractBaseUtilsTest.java b/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/service/AbstractBaseUtilsTest.java
new file mode 100644
index 000000000..c5322886c
--- /dev/null
+++ b/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/service/AbstractBaseUtilsTest.java
@@ -0,0 +1,204 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * ONAP : APPC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * 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
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * 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.lcm.service;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.Action;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.status.Status;
+import org.onap.appc.domainmodel.lcm.ResponseContext;
+import org.onap.appc.executor.objects.LCMCommandStatus;
+import org.onap.appc.executor.objects.Params;
+import org.onap.appc.requesthandler.objects.RequestHandlerOutput;
+
+import java.text.ParseException;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+public class AbstractBaseUtilsTest {
+
+    private AbstractBaseUtilsTest.testAbc testAbstractBaseUtils;
+
+    class testAbc extends AbstractBaseUtils {
+        // no content needed
+    }
+
+    @Before
+    public void setUp() throws Exception {
+        testAbstractBaseUtils = spy(new AbstractBaseUtilsTest.testAbc());
+    }
+
+    private void validateStatusResult(Params params, LCMCommandStatus lcmCommandStatus, Status status) {
+        Assert.assertEquals(String.format("Should return proper code of %s", lcmCommandStatus.toString()),
+            Integer.valueOf(lcmCommandStatus.getResponseCode()), status.getCode());
+        Assert.assertEquals(String.format("Should return proper message of $s", lcmCommandStatus.toString()),
+            lcmCommandStatus.getFormattedMessage(params), status.getMessage());
+    }
+
+    @Test
+    public void testBuildStatusWithoutParams() throws Exception {
+        LCMCommandStatus lcmCommandStatus = LCMCommandStatus.ACCEPTED;
+        Status status = testAbstractBaseUtils.buildStatusWithoutParams(lcmCommandStatus);
+        validateStatusResult(null, lcmCommandStatus, status);
+    }
+
+    @Test
+    public void testBuildStatusForErrorMsg() throws Exception {
+        String key = "errorMsg";
+        String msg = "testing";
+        Params params = new Params().addParam(key, msg);
+        LCMCommandStatus lcmCommandStatus = LCMCommandStatus.INVALID_INPUT_PARAMETER;
+        Status status = testAbstractBaseUtils.buildStatusForErrorMsg(lcmCommandStatus, msg);
+        verify(testAbstractBaseUtils, times(1)).buildStatus(lcmCommandStatus, msg, key);
+        validateStatusResult(params, lcmCommandStatus, status);
+    }
+
+
+    @Test
+    public void testBuildStatusForVnfId() throws Exception {
+        String key = "vnfId";
+        String msg = "testing";
+        Params params = new Params().addParam(key, msg);
+        LCMCommandStatus lcmCommandStatus = LCMCommandStatus.VNF_NOT_FOUND;
+        Status status = testAbstractBaseUtils.buildStatusForVnfId(lcmCommandStatus, msg);
+        verify(testAbstractBaseUtils, times(1)).buildStatus(lcmCommandStatus, msg, key);
+        validateStatusResult(params, lcmCommandStatus, status);
+    }
+
+    @Test
+    public void testBuildStatusForParamName() throws Exception {
+        String key = "paramName";
+        String msg = "testing";
+        Params params = new Params().addParam(key, msg);
+        LCMCommandStatus lcmCommandStatus = LCMCommandStatus.MISSING_MANDATORY_PARAMETER;
+        Status status = testAbstractBaseUtils.buildStatusForParamName(lcmCommandStatus, msg);
+        verify(testAbstractBaseUtils, times(1)).buildStatus(lcmCommandStatus, msg, key);
+        validateStatusResult(params, lcmCommandStatus, status);
+    }
+
+    @Test
+    public void testBuildStatusForId() throws Exception {
+        String key = "id";
+        String msg = "testing";
+        Params params = new Params().addParam(key, msg);
+        LCMCommandStatus lcmCommandStatus = LCMCommandStatus.VSERVER_NOT_FOUND;
+        Status status = testAbstractBaseUtils.buildStatusForId(lcmCommandStatus, msg);
+        verify(testAbstractBaseUtils, times(1)).buildStatus(lcmCommandStatus, msg, key);
+        validateStatusResult(params, lcmCommandStatus, status);
+    }
+
+    @Test
+    public void testBuildStatus() throws Exception {
+        String key = "errorMsg";
+        String msg = "testing";
+        Params params = new Params().addParam(key, msg);
+        LCMCommandStatus lcmCommandStatus = LCMCommandStatus.UNEXPECTED_ERROR;
+        Status status = testAbstractBaseUtils.buildStatus(lcmCommandStatus, msg, key);
+        validateStatusResult(params, lcmCommandStatus, status);
+
+        key = "vnfId";
+        params = new Params().addParam(key, msg);
+        lcmCommandStatus = LCMCommandStatus.VNF_NOT_FOUND;
+        status = testAbstractBaseUtils.buildStatus(lcmCommandStatus, msg, key);
+        validateStatusResult(params, lcmCommandStatus, status);
+
+        key = "paramName";
+        params = new Params().addParam(key, msg);
+        lcmCommandStatus = LCMCommandStatus.MISSING_MANDATORY_PARAMETER;
+        status = testAbstractBaseUtils.buildStatus(lcmCommandStatus, msg, key);
+        validateStatusResult(params, lcmCommandStatus, status);
+    }
+
+    @Test
+    public void testBuildStatusWithParseException() throws Exception {
+        LCMCommandStatus lcmCommandStatus = LCMCommandStatus.REQUEST_PARSING_FAILED;
+        String key = "errorMsg";
+        String exceptionMsg = null;
+
+        ParseException parseException = new ParseException(exceptionMsg, 0);
+        Params params = new Params().addParam(key, parseException.toString());
+        Status status = testAbstractBaseUtils.buildStatusWithParseException(parseException);
+        validateStatusResult(params, lcmCommandStatus, status);
+
+        exceptionMsg = "testing message";
+        parseException = new ParseException(exceptionMsg, 0);
+        params = new Params().addParam(key, exceptionMsg);
+        status = testAbstractBaseUtils.buildStatusWithParseException(parseException);
+        validateStatusResult(params, lcmCommandStatus, status);
+    }
+
+    @Test
+    public void testBuildStatusWithDispatcherOutput() throws Exception {
+        RequestHandlerOutput mockOutput = mock(RequestHandlerOutput.class);
+
+        ResponseContext mockContext = mock(ResponseContext.class);
+        Mockito.doReturn(mockContext).when(mockOutput).getResponseContext();
+
+        org.onap.appc.domainmodel.lcm.Status mockStatus = mock(org.onap.appc.domainmodel.lcm.Status.class);
+        Mockito.doReturn(mockStatus).when(mockContext).getStatus();
+
+        Integer resultCode = new Integer(401);
+        String resultMsg = "testing result message";
+        Mockito.doReturn(resultCode).when(mockStatus).getCode();
+        Mockito.doReturn(resultMsg).when(mockStatus).getMessage();
+
+        Status status = testAbstractBaseUtils.buildStatusWithDispatcherOutput(mockOutput);
+        Assert.assertEquals("Should return result code", resultCode, status.getCode());
+        Assert.assertEquals("Should return result message", resultMsg, status.getMessage());
+    }
+
+    @Test
+    public void testGetRpcName() throws Exception {
+        Assert.assertEquals("Should return action-status",
+            "action-status", testAbstractBaseUtils.getRpcName(Action.ActionStatus));
+        Assert.assertEquals("Should return query",
+            "query", testAbstractBaseUtils.getRpcName(Action.Query));
+        Assert.assertEquals("Should return reboot",
+            "reboot", testAbstractBaseUtils.getRpcName(Action.Reboot));
+        Assert.assertEquals("Should return attach-volume",
+            "attach-volume", testAbstractBaseUtils.getRpcName(Action.AttachVolume));
+        Assert.assertEquals("Should return detach-volume",
+            "detach-volume", testAbstractBaseUtils.getRpcName(Action.DetachVolume));
+        Assert.assertEquals("Should return quiesce-traffic",
+            "quiesce-traffic", testAbstractBaseUtils.getRpcName(Action.QuiesceTraffic));
+        Assert.assertEquals("Should return resume-traffic",
+                "resume-traffic", testAbstractBaseUtils.getRpcName(Action.ResumeTraffic));
+        Assert.assertEquals("Should return upgrade-pre-check",
+                "upgrade-pre-check", testAbstractBaseUtils.getRpcName(Action.UpgradePreCheck));
+        Assert.assertEquals("Should return upgrade-post-check",
+                "upgrade-post-check", testAbstractBaseUtils.getRpcName(Action.UpgradePostCheck));
+        Assert.assertEquals("Should return upgrade-software",
+                "upgrade-software", testAbstractBaseUtils.getRpcName(Action.UpgradeSoftware));
+        Assert.assertEquals("Should return upgrade-backup",
+                "upgrade-backup", testAbstractBaseUtils.getRpcName(Action.UpgradeBackup));
+        Assert.assertEquals("Should return upgrade-backout",
+                "upgrade-backout", testAbstractBaseUtils.getRpcName(Action.UpgradeBackout));
+    }
+}
diff --git a/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/service/ActionStatusServiceTest.java b/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/service/ActionStatusServiceTest.java
new file mode 100644
index 000000000..66fffeac7
--- /dev/null
+++ b/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/service/ActionStatusServiceTest.java
@@ -0,0 +1,197 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * ONAP : APPC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * 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
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * 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.lcm.service;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+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.ActionStatusOutputBuilder;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.Payload;
+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.common.header.CommonHeader;
+import org.onap.appc.domainmodel.lcm.ActionLevel;
+import org.onap.appc.domainmodel.lcm.RequestContext;
+import org.onap.appc.domainmodel.lcm.ResponseContext;
+import org.onap.appc.domainmodel.lcm.Status;
+import org.onap.appc.executor.objects.LCMCommandStatus;
+import org.onap.appc.provider.lcm.util.RequestInputBuilder;
+import org.onap.appc.requesthandler.objects.RequestHandlerInput;
+import org.onap.appc.requesthandler.objects.RequestHandlerOutput;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+import org.powermock.reflect.Whitebox;
+
+import java.text.ParseException;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.powermock.api.mockito.PowerMockito.whenNew;
+
+
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({ActionStatusService.class, RequestExecutor.class, RequestInputBuilder.class,})
+public class ActionStatusServiceTest {
+    private RequestHandlerInput mockRequestHandlerInput = mock(RequestHandlerInput.class);
+    private RequestContext mockRequestContext = mock(RequestContext.class);
+    private RequestHandlerOutput mockOutput = mock(RequestHandlerOutput.class);
+    private ResponseContext mockResponseContext = mock(ResponseContext.class);
+
+    private ActionStatusService actionStatusService;
+
+    @Before
+    public void setUp() throws Exception {
+        Mockito.doReturn(mockRequestContext).when(mockRequestHandlerInput).getRequestContext();
+        actionStatusService = spy(new ActionStatusService());
+    }
+
+    @Test
+    public void testConstructor() throws Exception {
+        Assert.assertEquals("Should have proper ACTION", Action.ActionStatus,
+            (Action) Whitebox.getInternalState(actionStatusService, "expectedAction"));
+        Assert.assertEquals("Should have action-status RPC name", "action-status",
+            (Whitebox.getInternalState(actionStatusService, "rpcName")).toString());
+    }
+
+    @Test
+    public void testQueryStatus() throws Exception {
+        // ===========   test input validation ============
+        CommonHeader mockCommonHeader = mock(CommonHeader.class);
+        ActionStatusInput mockInput = mock(ActionStatusInput.class);
+
+        Mockito.doReturn(mockCommonHeader).when(mockInput).getCommonHeader();
+        // test commonHeader error
+        ActionStatusOutputBuilder output = actionStatusService.queryStatus(mockInput);
+        Assert.assertEquals("Should have commonHeader", mockCommonHeader, output.getCommonHeader());
+        Assert.assertEquals("should return missing parameter",
+            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()),
+            output.getStatus().getCode());
+
+        ZULU zuluTimeStamp = new ZULU("2017-06-29T21:44:00.35Z");
+        Mockito.doReturn(zuluTimeStamp).when(mockCommonHeader).getTimestamp();
+        Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
+        Mockito.doReturn("originator Id").when(mockCommonHeader).getOriginatorId();
+        Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
+
+        // test invalid action
+        Mockito.doReturn(Action.Query).when(mockInput).getAction();
+        output = actionStatusService.queryStatus(mockInput);
+        Assert.assertEquals("Should have commonHeader", mockCommonHeader, output.getCommonHeader());
+        Assert.assertEquals("Should return invalid parameter for action",
+            Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()),
+            output.getStatus().getCode());
+
+        // test null actionIdentifier
+        Mockito.doReturn(Action.ActionStatus).when(mockInput).getAction();
+        output = actionStatusService.queryStatus(mockInput);
+        Assert.assertEquals("Should have commonHeader", mockCommonHeader, output.getCommonHeader());
+        Assert.assertEquals("should return missing parameter",
+            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()),
+            output.getStatus().getCode());
+
+        // test missing VNF ID
+        ActionIdentifiers mockAI = mock(ActionIdentifiers.class);
+        Mockito.doReturn(mockAI).when(mockInput).getActionIdentifiers();
+        output = actionStatusService.queryStatus(mockInput);
+        Assert.assertEquals("Should have commonHeader", mockCommonHeader, output.getCommonHeader());
+        Assert.assertEquals("should return missing parameter",
+            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()),
+            output.getStatus().getCode());
+
+        // test invalid VNF ID
+        Mockito.doReturn("").when(mockAI).getVnfId();
+        output = actionStatusService.queryStatus(mockInput);
+        Assert.assertEquals("Should have commonHeader", mockCommonHeader, output.getCommonHeader());
+        Assert.assertEquals("Should return invalid parameter for action",
+            Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()),
+            output.getStatus().getCode());
+
+        // test null payload
+        Mockito.doReturn("test VNF ID").when(mockAI).getVnfId();
+        output = actionStatusService.queryStatus(mockInput);
+        Assert.assertEquals("Should have commonHeader", mockCommonHeader, output.getCommonHeader());
+        Assert.assertEquals("should return missing parameter",
+            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()),
+            output.getStatus().getCode());
+
+        // test payload with empty string
+        Payload mockPayload = mock(Payload.class);
+        Mockito.doReturn(mockPayload).when(mockInput).getPayload();
+        output = actionStatusService.queryStatus(mockInput);
+        Assert.assertEquals("Should have commonHeader", mockCommonHeader, output.getCommonHeader());
+        Assert.assertEquals("should return invalid parameter",
+            Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()),
+            output.getStatus().getCode());
+
+        // test validation passed
+        Mockito.doReturn("testing payload").when(mockPayload).getValue();
+
+        // ===========   test success ============
+        RequestExecutor mockExecutor = mock(RequestExecutor.class);
+        whenNew(RequestExecutor.class).withNoArguments().thenReturn(mockExecutor);
+        Mockito.doReturn(mockOutput).when(mockExecutor).executeRequest(any());
+        Mockito.doReturn(mockPayload).when(mockExecutor).getPayload(mockOutput);
+
+        Mockito.doReturn(mockResponseContext).when(mockOutput).getResponseContext();
+
+        Integer statusCode = 400;
+        Status mockStatus = mock(Status.class);
+        Mockito.doReturn(statusCode).when(mockStatus).getCode();
+        Mockito.doReturn(mockStatus).when(mockResponseContext).getStatus();
+
+        output = actionStatusService.queryStatus(mockInput);
+        Mockito.verify(actionStatusService, times(1)).buildStatusWithDispatcherOutput(mockOutput);
+        Mockito.verify(mockExecutor, times(1)).getPayload(mockOutput);
+        Assert.assertTrue("Should have payload", output.getPayload() != null);
+        Assert.assertEquals("Should have commonHeader", mockCommonHeader, output.getCommonHeader());
+        Assert.assertEquals("Should return proper code", statusCode, output.getStatus().getCode());
+
+        // ===========   test parserException ============
+        RequestInputBuilder mockInputBuilder = mock(RequestInputBuilder.class);
+        whenNew(RequestInputBuilder.class).withNoArguments().thenReturn(mockInputBuilder);
+        Mockito.doReturn(mockInputBuilder).when(mockInputBuilder).requestContext();
+        ParseException parserException = new ParseException("testing exception", 0);
+        Mockito.doThrow(parserException).when(mockInputBuilder).commonHeader(mockCommonHeader);
+
+        output = actionStatusService.queryStatus(mockInput);
+        Mockito.verify(actionStatusService, times(1)).buildStatusWithParseException(parserException);
+        Assert.assertEquals("Should have commonHeader", mockCommonHeader, output.getCommonHeader());
+        Assert.assertEquals("Should return request failed",
+            Integer.valueOf(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()),
+            output.getStatus().getCode());
+    }
+
+    @Test
+    public void testUpdateToMgmtActionLevel() throws Exception {
+        actionStatusService.updateToMgmtActionLevel(mockRequestHandlerInput);
+        Mockito.verify(mockRequestContext, times(1)).setActionLevel(ActionLevel.MGMT);
+    }
+}
diff --git a/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/service/QueryServiceTest.java b/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/service/QueryServiceTest.java
new file mode 100644
index 000000000..be3370fd9
--- /dev/null
+++ b/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/service/QueryServiceTest.java
@@ -0,0 +1,175 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * ONAP : APPC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * 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
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * 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.lcm.service;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+import org.mockito.internal.util.reflection.Whitebox;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.Action;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.QueryInput;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.QueryOutputBuilder;
+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.common.header.CommonHeader;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.query.output.QueryResults;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.status.Status;
+import org.onap.appc.domainmodel.lcm.ResponseContext;
+import org.onap.appc.executor.objects.LCMCommandStatus;
+import org.onap.appc.requesthandler.objects.RequestHandlerOutput;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.powermock.api.mockito.PowerMockito.whenNew;
+
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({QueryService.class, RequestExecutor.class})
+public class QueryServiceTest {
+    private final Action myAction = Action.Query;
+
+    private QueryInput mockInput = mock(QueryInput.class);
+    private CommonHeader mockCommonHeader = mock(CommonHeader.class);
+    private ActionIdentifiers mockAI = mock(ActionIdentifiers.class);
+
+    private QueryService queryService;
+
+    @Before
+    public void setUp() throws Exception {
+        queryService = spy(new QueryService());
+
+        Mockito.doReturn(mockCommonHeader).when(mockInput).getCommonHeader();
+    }
+
+    @Test
+    public void testConstructor() throws Exception {
+        Assert.assertEquals("Should have proper ACTION", myAction,
+            (Action) org.powermock.reflect.Whitebox.getInternalState(queryService, "expectedAction"));
+        Assert.assertEquals("Should have query RPC name", myAction.name().toLowerCase(),
+            (org.powermock.reflect.Whitebox.getInternalState(queryService, "rpcName")).toString());
+    }
+
+    @Test
+    public void testProcess() throws Exception {
+        // test error occurs in validation
+        QueryOutputBuilder queryOutputBuilder = queryService.process(mockInput);
+        Mockito.verify(queryService, times(0)).proceedAction(mockInput);
+        Assert.assertTrue("Should have commonHeader",queryOutputBuilder.getCommonHeader() != null);
+        Assert.assertTrue("Should not have queryResults",queryOutputBuilder.getQueryResults() == null);
+        Assert.assertEquals("should return missing parameter status",
+            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()),
+            queryOutputBuilder.getStatus().getCode());
+
+        // to make validation pass
+        ZULU zuluTimeStamp = new ZULU("2017-06-29T21:44:00.35Z");
+        Mockito.doReturn(zuluTimeStamp).when(mockCommonHeader).getTimestamp();
+        Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
+        Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
+        Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
+
+        Mockito.doReturn(myAction).when(mockInput).getAction();
+        Mockito.doReturn(mockAI).when(mockInput).getActionIdentifiers();
+        Mockito.doReturn("vnfId").when(mockAI).getVnfId();
+
+        // test processAction return with error
+        queryOutputBuilder = queryService.process(mockInput);
+        Mockito.verify(queryService, times(1)).proceedAction(mockInput);
+        Assert.assertTrue("Should have commonHeader",queryOutputBuilder.getCommonHeader() != null);
+        Assert.assertTrue("Should not have queryResults",queryOutputBuilder.getQueryResults() == null);
+        Assert.assertEquals("should return rejected status",
+            Integer.valueOf(LCMCommandStatus.REJECTED.getResponseCode()),
+            queryOutputBuilder.getStatus().getCode());
+
+        // test processAction return without error
+        RequestExecutor mockExecutor = mock(RequestExecutor.class);
+        whenNew(RequestExecutor.class).withNoArguments().thenReturn(mockExecutor);
+
+        RequestHandlerOutput mockOutput = mock(RequestHandlerOutput.class);
+        Mockito.doReturn(mockOutput).when(mockExecutor).executeRequest(any());
+
+        ResponseContext mockResponseContext = mock(ResponseContext.class);
+        Mockito.doReturn(mockResponseContext).when(mockOutput).getResponseContext();
+
+        List<QueryResults> results = new ArrayList<>();
+        QueryResults mockResult = mock(QueryResults.class);
+        results.add(mockResult);
+        Mockito.doReturn(results).when(mockResponseContext).getPayloadObject();
+
+        org.onap.appc.domainmodel.lcm.Status mockStatus = mock(org.onap.appc.domainmodel.lcm.Status.class);
+        Integer successCode = Integer.valueOf(LCMCommandStatus.SUCCESS.getResponseCode());
+        Mockito.doReturn(successCode).when(mockStatus).getCode();
+        Mockito.doReturn(mockStatus).when(mockResponseContext).getStatus();
+
+        queryOutputBuilder = queryService.process(mockInput);
+        Assert.assertTrue("Should have commonHeader",queryOutputBuilder.getCommonHeader() != null);
+        Assert.assertEquals("Should have queryResults", results, queryOutputBuilder.getQueryResults());
+        Assert.assertEquals("should return success status", successCode, queryOutputBuilder.getStatus().getCode());
+    }
+
+    @Test
+    public void testValidate() throws Exception {
+        // test commonHeader error
+        queryService.validate(mockInput);
+        Status status = (Status) Whitebox.getInternalState(queryService, "status");
+        Assert.assertEquals("should return missing parameter",
+            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
+        Mockito.verify(queryService, times(0)).buildStatusForParamName(any(), any());
+        Mockito.verify(queryService, times(0)).buildStatusForErrorMsg(any(), any());
+
+        ZULU mockTimeStamp = mock(ZULU.class);
+        Mockito.doReturn(mockTimeStamp).when(mockCommonHeader).getTimestamp();
+        Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
+        Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
+        Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
+
+        // test empty ActionIdentifier
+        Mockito.doReturn(mockAI).when(mockInput).getActionIdentifiers();
+        Mockito.doReturn(myAction).when(mockInput).getAction();
+        queryService.validate(mockInput);
+        status = (Status) Whitebox.getInternalState(queryService, "status");
+        Assert.assertEquals("should return missing parameter",
+            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
+
+        // test empty VNF_ID
+        Mockito.doReturn("").when(mockAI).getVnfId();
+        queryService.validate(mockInput);
+        status = (Status) Whitebox.getInternalState(queryService, "status");
+        Assert.assertEquals("should return invalid parameter",
+            Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());
+
+        // test calling validateExcludeActId
+        Mockito.doReturn("vnfId").when(mockAI).getVnfId();
+        queryService.validate(mockInput);
+        Mockito.verify(queryService, times(1)).validateExcludedActIds(any(), any());
+    }
+}
diff --git a/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/service/QuiesceTrafficServiceTest.java b/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/service/QuiesceTrafficServiceTest.java
new file mode 100644
index 000000000..b6dc15ce3
--- /dev/null
+++ b/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/service/QuiesceTrafficServiceTest.java
@@ -0,0 +1,186 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * ONAP : APPC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * 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
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * 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.lcm.service;
+
+import org.junit.Assert;
+import junit.framework.TestCase;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+import org.mockito.internal.util.reflection.Whitebox;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.*;
+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.common.header.CommonHeader;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.status.Status;
+import org.onap.appc.domainmodel.lcm.ResponseContext;
+import org.onap.appc.executor.objects.LCMCommandStatus;
+import org.onap.appc.requesthandler.objects.RequestHandlerOutput;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.powermock.api.mockito.PowerMockito.whenNew;
+
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({QuiesceTrafficService.class, RequestExecutor.class})
+public class QuiesceTrafficServiceTest {
+    private final Action myAction = Action.QuiesceTraffic;
+    private final String PAYLOAD_STRING = "{\"A\":\"A-value\",\"B\":{\"C\":\"B.C-value\",\"D\":\"B.D-value\"}}";
+    private QuiesceTrafficInput mockInput = mock(QuiesceTrafficInput.class);
+    private CommonHeader mockCommonHeader = mock(CommonHeader.class);
+    private ActionIdentifiers mockAI = mock(ActionIdentifiers.class);
+    private Payload mockPayload = mock(Payload.class);
+
+    private QuiesceTrafficService quiesceServiceAction;
+    @Before
+    public void setUp() throws Exception {
+        quiesceServiceAction = spy(new QuiesceTrafficService());
+    }
+
+
+    @Test
+    public void testConstructor() throws Exception {
+        Action expectedAction = Action.QuiesceTraffic;
+        Assert.assertEquals("Should have proper ACTION", expectedAction,
+                (Action) org.powermock.reflect.Whitebox.getInternalState(quiesceServiceAction, "expectedAction"));
+        Assert.assertEquals("Should have quiesce-traffic RPC name", "quiesce-traffic",
+                (org.powermock.reflect.Whitebox.getInternalState(quiesceServiceAction, "rpcName")).toString());
+    }
+
+//    @Test
+//    public void testProcess() throws Exception {
+//        // test error occurs in validation
+//        QuiesceTrafficOutputBuilder outputBuilder = quiesceServiceAction.process(mockInput);
+//        Mockito.verify(quiesceServiceAction, times(0)).proceedAction(any(),any(),any());
+//        Assert.assertTrue("Should not have commonHeader as we did not mock it",outputBuilder.getCommonHeader() == null);
+//        Assert.assertEquals("should return missing parameter status",
+//                Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()),
+//                outputBuilder.getStatus().getCode());
+//
+//        // make validation pass
+//        Mockito.doReturn(mockCommonHeader).when(mockInput).getCommonHeader();
+//        Mockito.doReturn(mockPayload).when(mockInput).getPayload();
+//        Mockito.doReturn(PAYLOAD_STRING).when(mockPayload).getValue();
+//        // to make validation pass
+//        ZULU zuluTimeStamp = new ZULU("2017-06-29T21:44:00.35Z");
+//        Mockito.doReturn(zuluTimeStamp).when(mockCommonHeader).getTimestamp();
+//        Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
+//        Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
+//        Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
+//
+//        Mockito.doReturn(myAction).when(mockInput).getAction();
+//        Mockito.doReturn(mockAI).when(mockInput).getActionIdentifiers();
+//        Mockito.doReturn("vnfId").when(mockAI).getVnfId();
+//
+//        // test processAction return with error
+//        outputBuilder = quiesceServiceAction.process(mockInput);
+//        Mockito.verify(quiesceServiceAction, times(1)).proceedAction(any(),any(),any());
+//        Assert.assertTrue("Should have commonHeader",outputBuilder.getCommonHeader() != null);
+//        Assert.assertEquals("should return rejected status",
+//                Integer.valueOf(LCMCommandStatus.REJECTED.getResponseCode()),
+//                outputBuilder.getStatus().getCode());
+//
+//        // test processAction return without error
+//        RequestExecutor mockExecutor = mock(RequestExecutor.class);
+//        whenNew(RequestExecutor.class).withNoArguments().thenReturn(mockExecutor);
+//
+//        RequestHandlerOutput mockOutput = mock(RequestHandlerOutput.class);
+//        Mockito.doReturn(mockOutput).when(mockExecutor).executeRequest(any());
+//
+//        ResponseContext mockResponseContext = mock(ResponseContext.class);
+//        Mockito.doReturn(mockResponseContext).when(mockOutput).getResponseContext();
+//
+//        org.onap.appc.domainmodel.lcm.Status mockStatus = mock(org.onap.appc.domainmodel.lcm.Status.class);
+//        Integer successCode = Integer.valueOf(LCMCommandStatus.SUCCESS.getResponseCode());
+//        Mockito.doReturn(successCode).when(mockStatus).getCode();
+//        Mockito.doReturn(mockStatus).when(mockResponseContext).getStatus();
+//
+//        outputBuilder = quiesceServiceAction.process(mockInput);
+//        Assert.assertTrue("Should have commonHeader",outputBuilder.getCommonHeader() != null);
+//        Assert.assertEquals("should return success status", successCode, outputBuilder.getStatus().getCode());
+//    }
+
+    @Test
+    public void testValidate() throws Exception {
+        quiesceServiceAction.validate(mockCommonHeader, Action.QuiesceTraffic, mockAI,mockPayload);
+        Status status = (Status) Whitebox.getInternalState(quiesceServiceAction, "status");
+        Assert.assertEquals("should return missing parameter",
+                Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
+        Mockito.verify(quiesceServiceAction, times(0)).buildStatusForParamName(any(), any());
+        Mockito.verify(quiesceServiceAction, times(0)).buildStatusForErrorMsg(any(), any());
+
+        ZULU mockTimeStamp = mock(ZULU.class);
+        Mockito.doReturn(mockTimeStamp).when(mockCommonHeader).getTimestamp();
+        Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
+        Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
+        Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
+
+        // test empty action
+        quiesceServiceAction.validate(mockCommonHeader, Action.QuiesceTraffic, mockAI,mockPayload);
+        status = (Status) Whitebox.getInternalState(quiesceServiceAction, "status");
+        Assert.assertEquals("Should return missing parameter for action",
+                Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
+
+        // test empty ActionIdentifier
+        quiesceServiceAction.validate(mockCommonHeader, Action.QuiesceTraffic, mockAI,mockPayload);
+        status = (Status) Whitebox.getInternalState(quiesceServiceAction, "status");
+        Assert.assertEquals("should return missing parameter",
+                Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
+
+        // test Invalid VNF_ID
+        Mockito.doReturn("").when(mockAI).getVnfId();
+        quiesceServiceAction.validate(mockCommonHeader, Action.QuiesceTraffic, mockAI,mockPayload);
+        status = (Status) Whitebox.getInternalState(quiesceServiceAction, "status");
+        Assert.assertEquals("should return invalid parameter",
+                Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());
+
+        // test null payload
+        Mockito.doReturn("vnfId").when(mockAI).getVnfId();
+        quiesceServiceAction.validate(mockCommonHeader, Action.QuiesceTraffic, mockAI, null);
+        Mockito.verify(quiesceServiceAction, times(1)).validateExcludedActIds(any(), any());
+        status = (Status) Whitebox.getInternalState(quiesceServiceAction, "status");
+        Assert.assertEquals("should return missing parameter",
+                Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
+
+        // test empty payload
+
+        Mockito.doReturn("").when(mockPayload).getValue();
+        quiesceServiceAction.validate(mockCommonHeader, Action.QuiesceTraffic, mockAI, mockPayload);
+        status = (Status) Whitebox.getInternalState(quiesceServiceAction, "status");
+        Assert.assertEquals("should return invalid parameter",
+                Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());
+
+        // test space payload
+        Mockito.doReturn(" ").when(mockPayload).getValue();
+        quiesceServiceAction.validate(mockCommonHeader, Action.QuiesceTraffic, mockAI, mockPayload);
+        status = (Status) Whitebox.getInternalState(quiesceServiceAction, "status");
+        Assert.assertEquals("should return invalid parameter",
+                Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());
+    }
+}
diff --git a/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/service/RebootServiceTest.java b/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/service/RebootServiceTest.java
new file mode 100644
index 000000000..fffebf944
--- /dev/null
+++ b/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/service/RebootServiceTest.java
@@ -0,0 +1,153 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * ONAP : APPC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * 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
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * 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.lcm.service;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.Action;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.Payload;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RebootInput;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.RebootOutputBuilder;
+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.status.Status;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.modules.junit4.PowerMockRunner;
+import org.powermock.reflect.Whitebox;
+
+import static org.mockito.Mockito.times;
+
+@RunWith(PowerMockRunner.class)
+public class RebootServiceTest {
+    private final String vserverId = "vserverId";
+
+    @Mock
+    private RebootService rebootService;
+    @Mock
+    private RebootInput rebootInput;
+    @Mock
+    private ActionIdentifiers actionIdentifiers;
+    @Mock
+    private org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.common.header.CommonHeader commonHeader;
+
+    private Payload payload;
+
+    @Before
+    public void setUp() throws Exception {
+        rebootService = new RebootService();
+        payload = new Payload("{\"reboot-type\":\"hard\"}");
+
+        PowerMockito.doReturn(actionIdentifiers).when(rebootInput).getActionIdentifiers();
+        PowerMockito.doReturn(payload).when(rebootInput).getPayload();
+        PowerMockito.doReturn(commonHeader).when(rebootInput).getCommonHeader();
+        PowerMockito.doReturn(new ZULU("2017-09-05T16:55:55.807Z")).when(commonHeader).getTimestamp();
+        PowerMockito.doReturn("2.00").when(commonHeader).getApiVer();
+        PowerMockito.doReturn("demo-lcm-stop-id#1").when(commonHeader).getRequestId();
+        PowerMockito.doReturn("demo-lcm-stop-id#2").when(commonHeader).getSubRequestId();
+        PowerMockito.doReturn("originator-id").when(commonHeader).getOriginatorId();
+        PowerMockito.doReturn(Action.Reboot).when(rebootInput).getAction();
+    }
+
+    @Test
+    public void testConstructor() throws Exception {
+        Action expectedAction = Action.Reboot;
+        Assert.assertEquals("Should have proper ACTION", expectedAction,
+            (Action) org.powermock.reflect.Whitebox.getInternalState(rebootService, "expectedAction"));
+        Assert.assertEquals("Should have reboot RPC name", expectedAction.name().toLowerCase(),
+            (org.powermock.reflect.Whitebox.getInternalState(rebootService, "rpcName")).toString());
+    }
+
+    @Test
+    public void testProcessAccepted() throws Exception {
+        PowerMockito.doReturn(vserverId).when(actionIdentifiers).getVserverId();
+        RebootOutputBuilder process = rebootService.process(rebootInput);
+        PowerMockito.verifyPrivate(rebootService, times(1)).invoke("validate", rebootInput);
+        Assert.assertNotNull(process.getCommonHeader());
+        Assert.assertNotNull(process.getStatus());
+    }
+
+    @Test
+    public void testProcessError() throws Exception {
+        RebootOutputBuilder process = rebootService.process(rebootInput);
+        PowerMockito.verifyPrivate(rebootService, times(1))
+            .invoke("validate", rebootInput);
+        Assert.assertNotNull(process.getStatus());
+    }
+
+    @Test
+    public void testValidateSuccess() throws Exception {
+        PowerMockito.doReturn(vserverId).when(actionIdentifiers).getVserverId();
+        Status validate = Whitebox.invokeMethod(rebootService, "validate", rebootInput);
+        Assert.assertNull(validate);
+    }
+
+    @Test
+    public void testValidateMissingVserverId() throws Exception {
+        PowerMockito.doReturn("").when(actionIdentifiers).getVserverId();
+        Whitebox.invokeMethod(rebootService, "validate", rebootInput);
+        Status status = Whitebox.getInternalState(rebootService, "status");
+        Assert.assertNotNull(status);
+    }
+
+    @Test
+    public void testValidateWrongAction() throws Exception {
+        PowerMockito.doReturn(Action.Audit).when(rebootInput).getAction();
+        PowerMockito.doReturn("").when(actionIdentifiers).getVserverId();
+        Whitebox.invokeMethod(rebootService, "validate", rebootInput);
+        Status status = Whitebox.getInternalState(rebootService, "status");
+        Assert.assertNotNull(status);
+    }
+
+    @Test
+    public void testValidateMissingActionIdentifier() throws Exception {
+        PowerMockito.doReturn(actionIdentifiers).when(rebootInput).getActionIdentifiers();
+        Whitebox.invokeMethod(rebootService, "validate", rebootInput);
+        Status status = Whitebox.getInternalState(rebootService, "status");
+        Assert.assertNotNull(status);
+    }
+
+    @Test
+    public void testValidateMissingRebootType() throws Exception {
+        Payload payload = new Payload("{}");
+        PowerMockito.doReturn(payload).when(rebootInput).getPayload();
+        PowerMockito.doReturn(vserverId).when(actionIdentifiers).getVserverId();
+        Whitebox.invokeMethod(rebootService, "validate", rebootInput);
+        Status status = Whitebox.getInternalState(rebootService, "status");
+        Assert.assertNotNull(status);
+    }
+
+    @Test
+    public void testValidateWrongRebootType() throws Exception {
+        Payload payload = new Payload("{\"reboot-type\":\"1\"}");
+        PowerMockito.doReturn(payload).when(rebootInput).getPayload();
+        PowerMockito.doReturn(vserverId).when(actionIdentifiers).getVserverId();
+        Whitebox.invokeMethod(rebootService, "validate", rebootInput);
+        Status status = Whitebox.getInternalState(rebootService, "status");
+        Assert.assertNotNull(status);
+    }
+}
diff --git a/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/service/RequestExecutorTest.java b/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/service/RequestExecutorTest.java
new file mode 100644
index 000000000..a2001809e
--- /dev/null
+++ b/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/service/RequestExecutorTest.java
@@ -0,0 +1,252 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * ONAP : APPC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * 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
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * 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.lcm.service;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.Payload;
+import org.onap.appc.domainmodel.lcm.ActionLevel;
+import org.onap.appc.domainmodel.lcm.CommonHeader;
+import org.onap.appc.domainmodel.lcm.RequestContext;
+import org.onap.appc.domainmodel.lcm.ResponseContext;
+import org.onap.appc.domainmodel.lcm.Status;
+import org.onap.appc.domainmodel.lcm.VNFOperation;
+import org.onap.appc.executor.objects.LCMCommandStatus;
+import org.onap.appc.executor.objects.Params;
+import org.onap.appc.i18n.Msg;
+import org.onap.appc.requesthandler.RequestHandler;
+import org.onap.appc.requesthandler.objects.RequestHandlerInput;
+import org.onap.appc.requesthandler.objects.RequestHandlerOutput;
+import org.osgi.framework.Bundle;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.FrameworkUtil;
+import org.osgi.framework.InvalidSyntaxException;
+import org.osgi.framework.ServiceReference;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+import java.util.Collection;
+import java.util.Iterator;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.powermock.api.mockito.PowerMockito.mockStatic;
+
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({FrameworkUtil.class})
+public class RequestExecutorTest {
+    private final VNFOperation vnfOperation = VNFOperation.ActionStatus;
+    private final ActionLevel actionLevel = ActionLevel.MGMT;
+
+    private Bundle mockBundle = mock(Bundle.class);
+    private BundleContext mockBundleContext = mock(BundleContext.class);
+
+    private RequestHandlerInput mockInput = mock(RequestHandlerInput.class);
+    private RequestContext mockRequestContext = mock(RequestContext.class);
+    private CommonHeader mockCommonHeader = mock(CommonHeader.class);
+    private RequestHandler mockHandler = mock(RequestHandler.class);
+
+    private RequestExecutor requestExecutor;
+
+    @Before
+    public void setUp() throws Exception {
+        mockStatic(FrameworkUtil.class);
+        PowerMockito.when(FrameworkUtil.getBundle(any())).thenReturn(mockBundle);
+
+        Mockito.doReturn(mockRequestContext).when(mockInput).getRequestContext();
+        Mockito.doReturn(mockCommonHeader).when(mockRequestContext).getCommonHeader();
+
+        requestExecutor = spy(new RequestExecutor());
+    }
+
+    @Test
+    public void testExecuteRequest() throws Exception {
+        // test RequestHandler is null
+        Mockito.doReturn(null).when(mockBundle).getBundleContext();
+        Mockito.doReturn(actionLevel).when(mockRequestContext).getActionLevel();
+        Mockito.doReturn(vnfOperation).when(mockRequestContext).getAction();
+
+        Params params = new Params().addParam("errorMsg", requestExecutor.CANNOT_PROCESS);
+        LCMCommandStatus lcmCommandStatus = LCMCommandStatus.REJECTED;
+        Msg msg = Msg.REQUEST_HANDLER_UNAVAILABLE;
+
+        RequestHandlerOutput output = requestExecutor.executeRequest(mockInput);
+        ResponseContext responseContext = output.getResponseContext();
+        Status status = responseContext.getStatus();
+        Assert.assertEquals("Should have rejected status code",
+            lcmCommandStatus.getResponseCode(), status.getCode());
+        Assert.assertEquals("Should have rejected CANNOT_PROCESS status message",
+            lcmCommandStatus.getFormattedMessage(params), status.getMessage());
+        Assert.assertEquals("Should have the same commonHeader",
+            mockCommonHeader, responseContext.getCommonHeader());
+        Mockito.verify(requestExecutor, times(1)).getRequestHandler(any());
+        Mockito.verify(requestExecutor, times(1))
+            .createRequestHandlerOutput(any(), any(), any(), any());
+
+        // to get RequestHandler
+        ServiceReference<RequestHandler> mockSvcRefs = mock(ServiceReference.class);
+        Iterator mockIterator = mock(Iterator.class);
+        Mockito.doReturn(mockSvcRefs).when(mockIterator).next();
+
+        Collection<ServiceReference<RequestHandler>> mockSvcRefCollection = mock(Collection.class);
+        Mockito.doReturn(1).when(mockSvcRefCollection).size();
+        Mockito.doReturn(mockIterator).when(mockSvcRefCollection).iterator();
+
+        Mockito.doReturn(mockBundleContext).when(mockBundle).getBundleContext();
+        Mockito.doReturn(mockSvcRefCollection).when(mockBundleContext)
+            .getServiceReferences(eq(RequestHandler.class), anyString());
+
+        Mockito.doReturn(mockHandler).when(mockBundleContext).getService(mockSvcRefs);
+
+        // Skip test RequestHandler.quiesce throws exception as it does not throw exception
+
+        // test normal return
+        RequestHandlerOutput mockOutput = mock(RequestHandlerOutput.class);
+        Mockito.doReturn(mockOutput).when(mockHandler).handleRequest(mockInput);
+        output = requestExecutor.executeRequest(mockInput);
+        Assert.assertEquals("Should return mockOuput", mockOutput, output);
+    }
+
+    @Test
+    public void testGetRequestHandler() throws Exception {
+        // test null BundleContext
+        Mockito.doReturn(null).when(mockBundle).getBundleContext();
+        RequestHandler requestHandler = requestExecutor.getRequestHandler(actionLevel);
+        Assert.assertTrue("Should return null", requestHandler == null);
+
+        // test successful returning RequestHandler
+        ServiceReference<RequestHandler> mockSvcRefs = mock(ServiceReference.class);
+        Iterator mockIterator = mock(Iterator.class);
+        Mockito.doReturn(mockSvcRefs).when(mockIterator).next();
+
+        Collection<ServiceReference<RequestHandler>> mockSvcRefCollection = mock(Collection.class);
+        Mockito.doReturn(1).when(mockSvcRefCollection).size();
+        Mockito.doReturn(mockIterator).when(mockSvcRefCollection).iterator();
+
+        Mockito.doReturn(mockBundleContext).when(mockBundle).getBundleContext();
+        Mockito.doReturn(mockSvcRefCollection).when(mockBundleContext)
+            .getServiceReferences(eq(RequestHandler.class), anyString());
+
+        Mockito.doReturn(mockHandler).when(mockBundleContext).getService(mockSvcRefs);
+
+        requestHandler = requestExecutor.getRequestHandler(actionLevel);
+        Assert.assertEquals("Should return RequestHandler", mockHandler, requestHandler);
+    }
+
+    @Test(expected = RuntimeException.class)
+    public void testGetRequesetHandlerWithInvalidSyntaxException() throws Exception {
+        Mockito.doReturn(mockBundleContext).when(mockBundle).getBundleContext();
+        Mockito.doThrow(new InvalidSyntaxException("testing message", "testing filter"))
+            .when(mockBundleContext).getServiceReferences(eq(RequestHandler.class), anyString());
+
+        requestExecutor.getRequestHandler(actionLevel);
+    }
+
+
+    @Test(expected = RuntimeException.class)
+    public void testGetRequesetHandlerWithCannotFoundSvc() throws Exception {
+        Collection<ServiceReference<RequestHandler>> mockSvcRefCollection = mock(Collection.class);
+        Mockito.doReturn(2).when(mockSvcRefCollection).size();
+
+        Mockito.doReturn(mockBundleContext).when(mockBundle).getBundleContext();
+        Mockito.doReturn(mockSvcRefCollection).when(mockBundleContext)
+            .getServiceReferences(eq(RequestHandler.class), anyString());
+
+        requestExecutor.getRequestHandler(actionLevel);
+    }
+
+    @Test
+    public void testCreateRequestHandlerOutput() throws Exception {
+        // test exception without message
+        Exception testException = new Exception();
+        Params params = new Params().addParam("errorMsg", testException.toString());
+        LCMCommandStatus lcmCommandStatus = LCMCommandStatus.REJECTED;
+        Msg msg = Msg.REQUEST_HANDLER_UNAVAILABLE;
+
+        RequestHandlerOutput output =
+            requestExecutor.createRequestHandlerOutput(mockInput, lcmCommandStatus, msg, testException);
+        ResponseContext responseContext = output.getResponseContext();
+        Status status = responseContext.getStatus();
+        Assert.assertEquals("Should have the same status code",
+            lcmCommandStatus.getResponseCode(), status.getCode());
+        Assert.assertEquals("Should have the proper exception to String status message",
+            lcmCommandStatus.getFormattedMessage(params), status.getMessage());
+        Assert.assertEquals("Should have the same commonHeader",
+            mockCommonHeader, responseContext.getCommonHeader());
+
+        // test exception with message
+        testException = new Exception("testing exception");
+        params = new Params().addParam("errorMsg", testException.getMessage());
+        lcmCommandStatus = LCMCommandStatus.UNEXPECTED_ERROR;
+        msg = Msg.EXCEPTION_CALLING_DG;
+
+        output =
+            requestExecutor.createRequestHandlerOutput(mockInput, lcmCommandStatus, msg, testException);
+        responseContext = output.getResponseContext();
+        status = responseContext.getStatus();
+        Assert.assertEquals("Should have the same status code",
+            lcmCommandStatus.getResponseCode(), status.getCode());
+        Assert.assertEquals("Should have the proper exception to String status message",
+            lcmCommandStatus.getFormattedMessage(params), status.getMessage());
+        Assert.assertEquals("Should have the same commonHeader",
+            mockCommonHeader, responseContext.getCommonHeader());
+    }
+
+    @Test
+    public void testGetPayload() throws Exception {
+        RequestHandlerOutput mockOutput = mock(RequestHandlerOutput.class);
+        ResponseContext mockResponseContext = mock(ResponseContext.class);
+        // test null response context
+        Mockito.doReturn(null).when(mockOutput).getResponseContext();
+        Assert.assertTrue("Should return null with null requestContext",
+            requestExecutor.getPayload(mockOutput) == null);
+
+        // test null payload
+        Mockito.doReturn(mockResponseContext).when(mockOutput).getResponseContext();
+        Mockito.doReturn(null).when(mockResponseContext).getPayload();
+        Assert.assertTrue("Should return null with null payload",
+            requestExecutor.getPayload(mockOutput) == null);
+
+        // test empty payload
+        Mockito.doReturn("").when(mockResponseContext).getPayload();
+        Assert.assertTrue("Should return null with empty payload",
+            requestExecutor.getPayload(mockOutput) == null);
+
+        // test proper payload
+        String testingPayload = "testing payload";
+        Mockito.doReturn(testingPayload).when(mockResponseContext).getPayload();
+        Payload payload = requestExecutor.getPayload(mockOutput);
+        Assert.assertEquals("Should return null with empty payload", testingPayload, payload.getValue());
+    }
+
+}
diff --git a/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/service/ResumeTrafficServiceTest.java b/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/service/ResumeTrafficServiceTest.java
new file mode 100644
index 000000000..2ea7ee0d2
--- /dev/null
+++ b/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/service/ResumeTrafficServiceTest.java
@@ -0,0 +1,162 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * ONAP : APPC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * 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
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * 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.lcm.service;
+
+import org.junit.Assert;
+import junit.framework.TestCase;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+import org.mockito.internal.util.reflection.Whitebox;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.*;
+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.common.header.CommonHeader;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.status.Status;
+import org.onap.appc.domainmodel.lcm.ResponseContext;
+import org.onap.appc.executor.objects.LCMCommandStatus;
+import org.onap.appc.requesthandler.objects.RequestHandlerOutput;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.powermock.api.mockito.PowerMockito.whenNew;
+
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({ResumeTrafficService.class, RequestExecutor.class})
+public class ResumeTrafficServiceTest {
+    private final Action myAction = Action.ResumeTraffic;
+
+    private ResumeTrafficInput mockInput = mock(ResumeTrafficInput.class);
+    private CommonHeader mockCommonHeader = mock(CommonHeader.class);
+    private ActionIdentifiers mockAI = mock(ActionIdentifiers.class);
+
+    private ResumeTrafficService resumeServiceAction;
+    @Before
+    public void setUp() throws Exception {
+        resumeServiceAction = spy(new ResumeTrafficService());
+    }
+
+
+    @Test
+    public void testConstructor() throws Exception {
+        Action expectedAction = Action.ResumeTraffic;
+        Assert.assertEquals("Should have proper ACTION", expectedAction,
+                (Action) org.powermock.reflect.Whitebox.getInternalState(resumeServiceAction, "expectedAction"));
+        Assert.assertEquals("Should have resume-traffic RPC name", "resume-traffic",
+                (org.powermock.reflect.Whitebox.getInternalState(resumeServiceAction, "rpcName")).toString());
+    }
+
+//    @Test
+//    public void testProcess() throws Exception {
+//        // test error occurs in validation
+//        ResumeTrafficOutputBuilder outputBuilder = resumeServiceAction.process(mockInput);
+//        Mockito.verify(resumeServiceAction, times(0)).proceedAction(any());
+//        Assert.assertTrue("Should not have commonHeader as we did not mock it",outputBuilder.getCommonHeader() == null);
+//        Assert.assertEquals("should return missing parameter status",
+//            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()),
+//            outputBuilder.getStatus().getCode());
+//
+//        // make validation pass
+//        Mockito.doReturn(mockCommonHeader).when(mockInput).getCommonHeader();
+//
+//        // to make validation pass
+//        ZULU zuluTimeStamp = new ZULU("2017-06-29T21:44:00.35Z");
+//        Mockito.doReturn(zuluTimeStamp).when(mockCommonHeader).getTimestamp();
+//        Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
+//        Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
+//        Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
+//
+//        Mockito.doReturn(myAction).when(mockInput).getAction();
+//        Mockito.doReturn(mockAI).when(mockInput).getActionIdentifiers();
+//        Mockito.doReturn("vnfId").when(mockAI).getVnfId();
+//
+//        // test processAction return with error
+//        outputBuilder = resumeServiceAction.process(mockInput);
+//        Mockito.verify(resumeServiceAction, times(1)).proceedAction(any());
+//        Assert.assertTrue("Should have commonHeader",outputBuilder.getCommonHeader() != null);
+//        Assert.assertEquals("should return rejected status",
+//            Integer.valueOf(LCMCommandStatus.REJECTED.getResponseCode()),
+//            outputBuilder.getStatus().getCode());
+//
+//        // test processAction return without error
+//        RequestExecutor mockExecutor = mock(RequestExecutor.class);
+//        whenNew(RequestExecutor.class).withNoArguments().thenReturn(mockExecutor);
+//
+//        RequestHandlerOutput mockOutput = mock(RequestHandlerOutput.class);
+//        Mockito.doReturn(mockOutput).when(mockExecutor).executeRequest(any());
+//
+//        ResponseContext mockResponseContext = mock(ResponseContext.class);
+//        Mockito.doReturn(mockResponseContext).when(mockOutput).getResponseContext();
+//
+//        org.onap.appc.domainmodel.lcm.Status mockStatus = mock(org.onap.appc.domainmodel.lcm.Status.class);
+//        Integer successCode = Integer.valueOf(LCMCommandStatus.SUCCESS.getResponseCode());
+//        Mockito.doReturn(successCode).when(mockStatus).getCode();
+//        Mockito.doReturn(mockStatus).when(mockResponseContext).getStatus();
+//
+//        outputBuilder = resumeServiceAction.process(mockInput);
+//        Assert.assertTrue("Should have commonHeader",outputBuilder.getCommonHeader() != null);
+//        Assert.assertEquals("should return success status", successCode, outputBuilder.getStatus().getCode());
+//    }
+
+    @Test
+    public void testValidate() throws Exception {
+        resumeServiceAction.validate(mockCommonHeader, Action.ResumeTraffic, mockAI);
+        Status status = (Status) Whitebox.getInternalState(resumeServiceAction, "status");
+        Assert.assertEquals("should return missing parameter",
+            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
+        Mockito.verify(resumeServiceAction, times(0)).buildStatusForParamName(any(), any());
+        Mockito.verify(resumeServiceAction, times(0)).buildStatusForErrorMsg(any(), any());
+
+        ZULU mockTimeStamp = mock(ZULU.class);
+        Mockito.doReturn(mockTimeStamp).when(mockCommonHeader).getTimestamp();
+        Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
+        Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
+        Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
+
+        // test empty action
+        resumeServiceAction.validate(mockCommonHeader, Action.ResumeTraffic, mockAI);
+        status = (Status) Whitebox.getInternalState(resumeServiceAction, "status");
+        Assert.assertEquals("Should return missing parameter for action",
+                Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
+
+        // test empty ActionIdentifier
+        resumeServiceAction.validate(mockCommonHeader, Action.ResumeTraffic, mockAI);
+        status = (Status) Whitebox.getInternalState(resumeServiceAction, "status");
+        Assert.assertEquals("should return missing parameter",
+                Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
+
+        // test Invalid VNF_ID
+        Mockito.doReturn("").when(mockAI).getVnfId();
+        resumeServiceAction.validate(mockCommonHeader, Action.ResumeTraffic, mockAI);
+        status = (Status) Whitebox.getInternalState(resumeServiceAction, "status");
+        Assert.assertEquals("should return invalid parameter",
+                Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());
+    }
+
+}
diff --git a/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/service/UpgradeServiceTest.java b/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/service/UpgradeServiceTest.java
new file mode 100644
index 000000000..3247a0e94
--- /dev/null
+++ b/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/service/UpgradeServiceTest.java
@@ -0,0 +1,686 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * ONAP : APPC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * 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
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * 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.lcm.service;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+import org.mockito.internal.util.reflection.Whitebox;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.*;
+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.common.header.CommonHeader;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.status.Status;
+import org.onap.appc.domainmodel.lcm.ResponseContext;
+import org.onap.appc.executor.objects.LCMCommandStatus;
+import org.onap.appc.requesthandler.objects.RequestHandlerOutput;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.*;
+import static org.powermock.api.mockito.PowerMockito.whenNew;
+
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({UpgradeService.class, RequestExecutor.class})
+public class UpgradeServiceTest {
+    private final String PAYLOAD_STRING = "{\"A\":\"A-value\",\"B\":{\"C\":\"B.C-value\",\"D\":\"B.D-value\"}}";
+    private UpgradePreCheckInput mockUpgradePreInput = mock(UpgradePreCheckInput.class);
+    private UpgradePostCheckInput mockUpgradePostInput = mock(UpgradePostCheckInput.class);
+    private UpgradeSoftwareInput mockUpgradeSoftInput = mock(UpgradeSoftwareInput.class);
+    private UpgradeBackupInput mockUpgradeBackupInput = mock(UpgradeBackupInput.class);
+    private UpgradeBackoutInput mockUpgradeBackoutInput = mock(UpgradeBackoutInput.class);
+    private CommonHeader mockCommonHeader = mock(CommonHeader.class);
+    private ActionIdentifiers mockAI = mock(ActionIdentifiers.class);
+    private Payload mockPayload = mock(Payload.class);
+
+    private UpgradeService upgradePreAction;
+    private UpgradeService upgradePostAction;
+    private UpgradeService upgradeSoftAction;
+    private UpgradeService upgradeBackupAction;
+    private UpgradeService upgradeBackoutAction;
+   
+    @Before
+    public void setUp() throws Exception {
+    	upgradePreAction = spy(new UpgradeService("upgradePre"));
+    	upgradePostAction = spy(new UpgradeService("upgradePost"));
+    	upgradeSoftAction = spy(new UpgradeService("upgradeSoft"));
+    	upgradeBackupAction = spy(new UpgradeService("upgradeBackup"));
+    	upgradeBackoutAction = spy(new UpgradeService("upgradeBackout"));
+    }
+
+    @Test
+    public void testConstructor() throws Exception {
+        Action expectedAction = Action.UpgradePreCheck;
+        Assert.assertEquals("Should have proper ACTION", expectedAction,
+            (Action) org.powermock.reflect.Whitebox.getInternalState(upgradePreAction, "expectedAction"));
+        Assert.assertEquals("Should have upgrade-precheck RPC name", "upgrade-pre-check",
+            (org.powermock.reflect.Whitebox.getInternalState(upgradePreAction, "rpcName")).toString());
+
+        expectedAction = Action.UpgradePostCheck;
+        Assert.assertEquals("Should have proper ACTION", expectedAction,
+            (Action) org.powermock.reflect.Whitebox.getInternalState(upgradePostAction, "expectedAction"));
+        Assert.assertEquals("Should have upgrade-postcheck RPC name","upgrade-post-check",
+            (org.powermock.reflect.Whitebox.getInternalState(upgradePostAction, "rpcName")).toString());
+
+         expectedAction = Action.UpgradeSoftware;
+        Assert.assertEquals("Should have proper ACTION", expectedAction,
+                (Action) org.powermock.reflect.Whitebox.getInternalState(upgradeSoftAction, "expectedAction"));
+        Assert.assertEquals("Should have upgrade-software RPC name", "upgrade-software",
+                (org.powermock.reflect.Whitebox.getInternalState(upgradeSoftAction, "rpcName")).toString());
+
+        expectedAction = Action.UpgradeBackup;
+        Assert.assertEquals("Should have proper ACTION", expectedAction,
+                (Action) org.powermock.reflect.Whitebox.getInternalState(upgradeBackupAction, "expectedAction"));
+        Assert.assertEquals("Should have upgrade-backup RPC name","upgrade-backup",
+                (org.powermock.reflect.Whitebox.getInternalState(upgradeBackupAction, "rpcName")).toString());
+
+        expectedAction = Action.UpgradeBackout;
+        Assert.assertEquals("Should have proper ACTION", expectedAction,
+                (Action) org.powermock.reflect.Whitebox.getInternalState(upgradeBackoutAction, "expectedAction"));
+        Assert.assertEquals("Should have upgrade-backout RPC name","upgrade-backout",
+                (org.powermock.reflect.Whitebox.getInternalState(upgradeBackoutAction, "rpcName")).toString());
+
+    }
+
+//    @Test
+//    public void testUpgradePreCheck() throws Exception {
+//        // test error occurs in validation
+//        UpgradePreCheckOutputBuilder outputBuilder = upgradePreAction.upgradePreCheck(mockUpgradePreInput);
+//        //Mockito.verify(upgradePreAction, times(0)).proceedAction(any(), any(), any());
+//        Assert.assertTrue("Should not have commonHeader as we did not mock it",
+//            outputBuilder.getCommonHeader() == null);
+//        Assert.assertEquals("should return missing parameter status",
+//            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()),
+//            outputBuilder.getStatus().getCode());
+//
+//        // make validation pass
+//        Mockito.doReturn(mockCommonHeader).when(mockUpgradePreInput).getCommonHeader();
+//        Mockito.doReturn(mockPayload).when(mockUpgradePreInput).getPayload();
+//        Mockito.doReturn(PAYLOAD_STRING).when(mockPayload).getValue();
+//
+//        ZULU zuluTimeStamp = new ZULU("2017-06-29T21:44:00.35Z");
+//        Mockito.doReturn(zuluTimeStamp).when(mockCommonHeader).getTimestamp();
+//        Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
+//        Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
+//        Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
+//
+//        Mockito.doReturn(Action.UpgradePreCheck).when(mockUpgradePreInput).getAction();
+//        Mockito.doReturn(mockAI).when(mockUpgradePreInput).getActionIdentifiers();
+//        Mockito.doReturn("vnfId").when(mockAI).getVnfId();
+//
+//        // test proceedAction return with error
+//        outputBuilder = upgradePreAction.upgradePreCheck(mockUpgradePreInput);
+//        //Mockito.verify(upgradePreAction, times(1)).proceedAction(any(), any(), any());
+//        Assert.assertTrue("Should have commonHeader",
+//            outputBuilder.getCommonHeader() != null);
+//        Assert.assertEquals("should return rejected status",
+//            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()),
+//            outputBuilder.getStatus().getCode());
+//
+//        // test proceedAction return without error
+//        RequestExecutor mockExecutor = mock(RequestExecutor.class);
+//        whenNew(RequestExecutor.class).withNoArguments().thenReturn(mockExecutor);
+//
+//        RequestHandlerOutput mockOutput = mock(RequestHandlerOutput.class);
+//        Mockito.doReturn(mockOutput).when(mockExecutor).executeRequest(any());
+//
+//        ResponseContext mockResponseContext = mock(ResponseContext.class);
+//        Mockito.doReturn(mockResponseContext).when(mockOutput).getResponseContext();
+//
+//        org.onap.appc.domainmodel.lcm.Status mockStatus = mock(org.onap.appc.domainmodel.lcm.Status.class);
+//        Integer successCode = Integer.valueOf(LCMCommandStatus.SUCCESS.getResponseCode());
+//        Mockito.doReturn(successCode).when(mockStatus).getCode();
+//        Mockito.doReturn(mockStatus).when(mockResponseContext).getStatus();
+//
+//        outputBuilder = upgradePreAction.upgradePreCheck(mockUpgradePreInput);
+//        Assert.assertTrue("Should have commonHeader",
+//            outputBuilder.getCommonHeader() != null);
+//        Assert.assertEquals("should return success status",
+//            new Integer(302), outputBuilder.getStatus().getCode());
+//    }
+//
+//    @Test
+//    public void testUpgradePostCheck() throws Exception {
+//        // test error occurs in validation
+//        UpgradePostCheckOutputBuilder outputBuilder = upgradePostAction.upgradePostCheck(mockUpgradePostInput);
+//       // Mockito.verify(upgradePostAction, times(0)).proceedAction(any(), any(), any());
+//        Assert.assertTrue("Should not have commonHeader as we did not mock it",
+//            outputBuilder.getCommonHeader() == null);
+//        Assert.assertEquals("should return missing parameter status",
+//            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()),
+//            outputBuilder.getStatus().getCode());
+//
+//        // make validation pass
+//        Mockito.doReturn(mockCommonHeader).when(mockUpgradePostInput).getCommonHeader();
+//        Mockito.doReturn(mockPayload).when(mockUpgradePostInput).getPayload();
+//        Mockito.doReturn(PAYLOAD_STRING).when(mockPayload).getValue();
+//
+//        ZULU zuluTimeStamp = new ZULU("2017-06-29T21:44:00.35Z");
+//        Mockito.doReturn(zuluTimeStamp).when(mockCommonHeader).getTimestamp();
+//        Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
+//        Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
+//        Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
+//
+//        Mockito.doReturn(Action.UpgradePostCheck).when(mockUpgradePostInput).getAction();
+//        Mockito.doReturn(mockAI).when(mockUpgradePostInput).getActionIdentifiers();
+//        Mockito.doReturn("vnfId").when(mockAI).getVnfId();
+//
+//        // test proceedAction return with error
+//        outputBuilder = upgradePostAction.upgradePostCheck(mockUpgradePostInput);
+//       // Mockito.verify(upgradePostAction, times(1)).proceedAction(any(), any(), any());
+//        Assert.assertTrue("Should have commonHeader",
+//            outputBuilder.getCommonHeader() != null);
+//        Assert.assertEquals("should return rejected status",
+//            Integer.valueOf(302),
+//            outputBuilder.getStatus().getCode());
+//
+//        // test proceedAction return without error
+//        RequestExecutor mockExecutor = mock(RequestExecutor.class);
+//        whenNew(RequestExecutor.class).withNoArguments().thenReturn(mockExecutor);
+//
+//        RequestHandlerOutput mockOutput = mock(RequestHandlerOutput.class);
+//        Mockito.doReturn(mockOutput).when(mockExecutor).executeRequest(any());
+//
+//        ResponseContext mockResponseContext = mock(ResponseContext.class);
+//        Mockito.doReturn(mockResponseContext).when(mockOutput).getResponseContext();
+//
+//        org.onap.appc.domainmodel.lcm.Status mockStatus = mock(org.onap.appc.domainmodel.lcm.Status.class);
+//        Integer successCode = Integer.valueOf(LCMCommandStatus.SUCCESS.getResponseCode());
+//        Mockito.doReturn(successCode).when(mockStatus).getCode();
+//        Mockito.doReturn(mockStatus).when(mockResponseContext).getStatus();;
+//
+//        outputBuilder = upgradePostAction.upgradePostCheck(mockUpgradePostInput);
+//        Assert.assertTrue("Should have commonHeader",
+//            outputBuilder.getCommonHeader() != null);
+//        Assert.assertEquals("should return success status",
+//                new Integer(302), outputBuilder.getStatus().getCode());
+//    }
+//    @Test
+//    public void testUpgradeSoftware() throws Exception {
+//        // test error occurs in validation
+//        UpgradeSoftwareOutputBuilder outputBuilder = upgradeSoftAction.upgradeSoftware(mockUpgradeSoftInput);
+//        //Mockito.verify(upgradeSoftAction, times(0)).proceedAction(any(), any(), any());
+//        Assert.assertTrue("Should not have commonHeader as we did not mock it",
+//                outputBuilder.getCommonHeader() == null);
+//        Assert.assertEquals("should return missing parameter status",
+//                Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()),
+//                outputBuilder.getStatus().getCode());
+//
+//        // make validation pass
+//        Mockito.doReturn(mockCommonHeader).when(mockUpgradeSoftInput).getCommonHeader();
+//        Mockito.doReturn(mockPayload).when(mockUpgradeSoftInput).getPayload();
+//        Mockito.doReturn(PAYLOAD_STRING).when(mockPayload).getValue();
+//
+//        ZULU zuluTimeStamp = new ZULU("2017-06-29T21:44:00.35Z");
+//        Mockito.doReturn(zuluTimeStamp).when(mockCommonHeader).getTimestamp();
+//        Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
+//        Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
+//        Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
+//
+//        Mockito.doReturn(Action.UpgradeSoftware).when(mockUpgradeSoftInput).getAction();
+//        Mockito.doReturn(mockAI).when(mockUpgradeSoftInput).getActionIdentifiers();
+//        Mockito.doReturn("vnfId").when(mockAI).getVnfId();
+//
+//        // test proceedAction return with error
+//        outputBuilder = upgradeSoftAction.upgradeSoftware(mockUpgradeSoftInput);
+//        //Mockito.verify(upgradeSoftAction, times(1)).proceedAction(any(), any(), any());
+//        Assert.assertTrue("Should have commonHeader",
+//                outputBuilder.getCommonHeader() != null);
+//        Assert.assertEquals("should return rejected status",
+//                Integer.valueOf(302),
+//                outputBuilder.getStatus().getCode());
+//
+//        // test proceedAction return without error
+//        RequestExecutor mockExecutor = mock(RequestExecutor.class);
+//        whenNew(RequestExecutor.class).withNoArguments().thenReturn(mockExecutor);
+//
+//        RequestHandlerOutput mockOutput = mock(RequestHandlerOutput.class);
+//        Mockito.doReturn(mockOutput).when(mockExecutor).executeRequest(any());
+//
+//        ResponseContext mockResponseContext = mock(ResponseContext.class);
+//        Mockito.doReturn(mockResponseContext).when(mockOutput).getResponseContext();
+//
+//        org.onap.appc.domainmodel.lcm.Status mockStatus = mock(org.onap.appc.domainmodel.lcm.Status.class);
+//        Integer successCode = Integer.valueOf(LCMCommandStatus.SUCCESS.getResponseCode());
+//        Mockito.doReturn(successCode).when(mockStatus).getCode();
+//        Mockito.doReturn(mockStatus).when(mockResponseContext).getStatus();
+//
+//        outputBuilder = upgradeSoftAction.upgradeSoftware(mockUpgradeSoftInput);
+//        Assert.assertTrue("Should have commonHeader",
+//                outputBuilder.getCommonHeader() != null);
+//        Assert.assertEquals("should return success status",
+//                new Integer(302), outputBuilder.getStatus().getCode());
+//    }
+//    @Test
+//    public void testUpgradeBackup() throws Exception {
+//        // test error occurs in validation
+//        UpgradeBackupOutputBuilder outputBuilder = upgradeBackupAction.upgradeBackup(mockUpgradeBackupInput);
+//        //Mockito.verify(upgradeBackupAction, times(0)).proceedAction(any(), any(), any());
+//        Assert.assertTrue("Should not have commonHeader as we did not mock it",
+//                outputBuilder.getCommonHeader() == null);
+//        Assert.assertEquals("should return missing parameter status",
+//                Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()),
+//                outputBuilder.getStatus().getCode());
+//
+//        // make validation pass
+//        Mockito.doReturn(mockCommonHeader).when(mockUpgradeBackupInput).getCommonHeader();
+//        Mockito.doReturn(mockPayload).when(mockUpgradeBackupInput).getPayload();
+//        Mockito.doReturn(PAYLOAD_STRING).when(mockPayload).getValue();
+//
+//        ZULU zuluTimeStamp = new ZULU("2017-06-29T21:44:00.35Z");
+//        Mockito.doReturn(zuluTimeStamp).when(mockCommonHeader).getTimestamp();
+//        Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
+//        Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
+//        Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
+//
+//        Mockito.doReturn(Action.UpgradeBackup).when(mockUpgradeBackupInput).getAction();
+//        Mockito.doReturn(mockAI).when(mockUpgradeBackupInput).getActionIdentifiers();
+//        Mockito.doReturn("vnfId").when(mockAI).getVnfId();
+//
+//        // test proceedAction return with error
+//        outputBuilder = upgradeBackupAction.upgradeBackup(mockUpgradeBackupInput);
+//        //Mockito.verify(upgradeBackupAction, times(1)).proceedAction(any(), any(), any());
+//        Assert.assertTrue("Should have commonHeader",
+//                outputBuilder.getCommonHeader() != null);
+//        Assert.assertEquals("should return rejected status",
+//                Integer.valueOf(302),
+//                outputBuilder.getStatus().getCode());
+//
+//        // test proceedAction return without error
+//        RequestExecutor mockExecutor = mock(RequestExecutor.class);
+//        whenNew(RequestExecutor.class).withNoArguments().thenReturn(mockExecutor);
+//
+//        RequestHandlerOutput mockOutput = mock(RequestHandlerOutput.class);
+//        Mockito.doReturn(mockOutput).when(mockExecutor).executeRequest(any());
+//
+//        ResponseContext mockResponseContext = mock(ResponseContext.class);
+//        Mockito.doReturn(mockResponseContext).when(mockOutput).getResponseContext();
+//
+//        org.onap.appc.domainmodel.lcm.Status mockStatus = mock(org.onap.appc.domainmodel.lcm.Status.class);
+//        Integer successCode = Integer.valueOf(LCMCommandStatus.SUCCESS.getResponseCode());
+//        Mockito.doReturn(successCode).when(mockStatus).getCode();
+//        Mockito.doReturn(mockStatus).when(mockResponseContext).getStatus();
+//
+//        outputBuilder = upgradeBackupAction.upgradeBackup(mockUpgradeBackupInput);
+//        Assert.assertTrue("Should have commonHeader",
+//                outputBuilder.getCommonHeader() != null);
+//        Assert.assertEquals("should return success status",
+//                new Integer(302), outputBuilder.getStatus().getCode());
+//    }
+//
+//    @Test
+//    public void testUpgradeBackout() throws Exception {
+//        // test error occurs in validation
+//        UpgradeBackoutOutputBuilder outputBuilder = upgradeBackoutAction.upgradeBackout(mockUpgradeBackoutInput);
+//        //Mockito.verify(upgradeBackoutAction, times(0)).proceedAction(any(), any(), any());
+//        Assert.assertTrue("Should not have commonHeader as we did not mock it",
+//                outputBuilder.getCommonHeader() == null);
+//        Assert.assertEquals("should return missing parameter status",
+//                Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()),
+//                outputBuilder.getStatus().getCode());
+//
+//        // make validation pass
+//        Mockito.doReturn(mockCommonHeader).when(mockUpgradeBackoutInput).getCommonHeader();
+//        Mockito.doReturn(mockPayload).when(mockUpgradeBackoutInput).getPayload();
+//        Mockito.doReturn(PAYLOAD_STRING).when(mockPayload).getValue();
+//
+//        ZULU zuluTimeStamp = new ZULU("2017-06-29T21:44:00.35Z");
+//        Mockito.doReturn(zuluTimeStamp).when(mockCommonHeader).getTimestamp();
+//        Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
+//        Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
+//        Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
+//
+//        Mockito.doReturn(Action.UpgradeBackup).when(mockUpgradeBackupInput).getAction();
+//        Mockito.doReturn(mockAI).when(mockUpgradeBackupInput).getActionIdentifiers();
+//        Mockito.doReturn("vnfId").when(mockAI).getVnfId();
+//
+//        // test proceedAction return with error
+//        outputBuilder = upgradeBackoutAction.upgradeBackout(mockUpgradeBackoutInput);
+//        //Mockito.verify(upgradeBackoutAction, times(1)).proceedAction(any(), any(), any());
+//        Assert.assertTrue("Should have commonHeader",
+//                outputBuilder.getCommonHeader() != null);
+//        Assert.assertEquals("should return rejected status",
+//                Integer.valueOf(302),
+//                outputBuilder.getStatus().getCode());
+//
+//        // test proceedAction return without error
+//        RequestExecutor mockExecutor = mock(RequestExecutor.class);
+//        whenNew(RequestExecutor.class).withNoArguments().thenReturn(mockExecutor);
+//
+//        RequestHandlerOutput mockOutput = mock(RequestHandlerOutput.class);
+//        Mockito.doReturn(mockOutput).when(mockExecutor).executeRequest(any());
+//
+//        ResponseContext mockResponseContext = mock(ResponseContext.class);
+//        Mockito.doReturn(mockResponseContext).when(mockOutput).getResponseContext();
+//
+//        org.onap.appc.domainmodel.lcm.Status mockStatus = mock(org.onap.appc.domainmodel.lcm.Status.class);
+//        Integer successCode = Integer.valueOf(LCMCommandStatus.SUCCESS.getResponseCode());
+//        Mockito.doReturn(successCode).when(mockStatus).getCode();
+//        Mockito.doReturn(mockStatus).when(mockResponseContext).getStatus();
+//
+//        outputBuilder = upgradeBackoutAction.upgradeBackout(mockUpgradeBackoutInput);
+//        Assert.assertTrue("Should have commonHeader",
+//                outputBuilder.getCommonHeader() != null);
+//        Assert.assertEquals("should return success status",
+//                new Integer(302), outputBuilder.getStatus().getCode());
+//    }
+//}
+
+//    @Test
+//    public void testValidateForPreCheckAction() throws Exception {
+//        // test commonHeader error
+//        upgradePreAction.validate(mockCommonHeader, Action.UpgradePreCheck, mockAI, mockPayload);
+//        Status status = (Status) Whitebox.getInternalState(upgradePreAction, "status");
+//        Assert.assertEquals("should return missing parameter",
+//            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
+//        //Mockito.verify(upgradePreAction, times(0)).buildStatusForParamName(any(), any());
+//       // Mockito.verify(upgradePreAction, times(0)).buildStatusForErrorMsg(any(), any());
+//
+//        ZULU mockTimeStamp = mock(ZULU.class);
+//        Mockito.doReturn(mockTimeStamp).when(mockCommonHeader).getTimestamp();
+//        Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
+//        Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
+//        Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
+//
+//        // test Invalid action
+//        upgradePreAction.validate(mockCommonHeader, Action.UpgradePreCheck, mockAI, mockPayload);
+//        status = (Status) Whitebox.getInternalState(upgradePreAction, "status");
+//        Assert.assertEquals("Should return invalid parameter for action",
+//            Integer.valueOf(302), status.getCode());
+//
+//        // test empty ActionIdentifier
+//        upgradePreAction.validate(mockCommonHeader, Action.UpgradePreCheck, mockAI, mockPayload);
+//        status = (Status) Whitebox.getInternalState(upgradePreAction, "status");
+//        Assert.assertEquals("should return missing parameter",
+//            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
+//
+//        // test empty VSERVER_ID
+//        Mockito.doReturn("").when(mockAI).getVnfId();
+//        upgradePreAction.validate(mockCommonHeader, Action.UpgradePreCheck, mockAI, mockPayload);
+//        status = (Status) Whitebox.getInternalState(upgradePreAction, "status");
+//        Assert.assertEquals("should return invalid parameter",
+//            Integer.valueOf(302), status.getCode());
+//
+//        Mockito.doReturn("vnfId").when(mockAI).getVnfId();
+//
+//        // test null payload
+//        upgradePreAction.validate(mockCommonHeader, Action.UpgradePreCheck, mockAI, null);
+//        //Mockito.verify(upgradePreAction, times(1)).validateExcludedActIds(any(), any());
+//        status = (Status) Whitebox.getInternalState(upgradePreAction, "status");
+//        Assert.assertEquals("should return missing parameter",
+//            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
+//
+//        // test empty payload
+//        Mockito.doReturn("").when(mockPayload).getValue();
+//        upgradePreAction.validate(mockCommonHeader, Action.UpgradePreCheck, mockAI, mockPayload);
+//        status = (Status) Whitebox.getInternalState(upgradePreAction, "status");
+//        Assert.assertEquals("should return invalid parameter",
+//            Integer.valueOf(302), status.getCode());
+//
+//        // test space payload
+//        Mockito.doReturn(" ").when(mockPayload).getValue();
+//        upgradePreAction.validate(mockCommonHeader, Action.UpgradePreCheck, mockAI, mockPayload);
+//        status = (Status) Whitebox.getInternalState(upgradePreAction, "status");
+//        Assert.assertEquals("should return invalid parameter",
+//            Integer.valueOf(302), status.getCode());
+//    }
+//
+//    @Test
+//    public void testValidateForUpgradePostAction() throws Exception {
+//        // test commonHeader error
+//        upgradePostAction.validate(mockCommonHeader, Action.UpgradePostCheck, mockAI, mockPayload);
+//        Status status = (Status) Whitebox.getInternalState(upgradePostAction, "status");
+//        Assert.assertEquals("should return missing parameter",
+//                Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
+//       // Mockito.verify(upgradePostAction, times(0)).buildStatusForParamName(any(), any());
+//        //Mockito.verify(upgradePostAction, times(0)).buildStatusForErrorMsg(any(), any());
+//
+//        ZULU mockTimeStamp = mock(ZULU.class);
+//        Mockito.doReturn(mockTimeStamp).when(mockCommonHeader).getTimestamp();
+//        Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
+//        Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
+//        Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
+//
+//        // test Invalid action
+//        upgradePostAction.validate(mockCommonHeader, Action.UpgradePostCheck, mockAI, mockPayload);
+//        status = (Status) Whitebox.getInternalState(upgradePostAction, "status");
+//        Assert.assertEquals("Should return invalid parameter for action",
+//                Integer.valueOf(302), status.getCode());
+//
+//        // test empty ActionIdentifier
+//        upgradePostAction.validate(mockCommonHeader, Action.UpgradePostCheck, mockAI, mockPayload);
+//        status = (Status) Whitebox.getInternalState(upgradePostAction, "status");
+//        Assert.assertEquals("should return missing parameter",
+//                Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
+//
+//        // test empty VSERVER_ID
+//        Mockito.doReturn("").when(mockAI).getVnfId();
+//        upgradePostAction.validate(mockCommonHeader, Action.UpgradePostCheck, mockAI, mockPayload);
+//        status = (Status) Whitebox.getInternalState(upgradePostAction, "status");
+//        Assert.assertEquals("should return invalid parameter",
+//                Integer.valueOf(302), status.getCode());
+//
+//        Mockito.doReturn("vnfId").when(mockAI).getVnfId();
+//
+//        // test null payload
+//        upgradePostAction.validate(mockCommonHeader, Action.UpgradePostCheck, mockAI, null);
+//        //Mockito.verify(upgradePostAction, times(1)).validateExcludedActIds(any(), any());
+//        status = (Status) Whitebox.getInternalState(upgradePostAction, "status");
+//        Assert.assertEquals("should return missing parameter",
+//                Integer.valueOf(302), status.getCode());
+//
+//        // test empty payload
+//        Mockito.doReturn("").when(mockPayload).getValue();
+//        upgradePostAction.validate(mockCommonHeader, Action.UpgradePostCheck, mockAI, mockPayload);
+//        status = (Status) Whitebox.getInternalState(upgradePostAction, "status");
+//        Assert.assertEquals("should return invalid parameter",
+//                Integer.valueOf(302), status.getCode());
+//
+//        // test space payload
+//        Mockito.doReturn(" ").when(mockPayload).getValue();
+//        upgradePostAction.validate(mockCommonHeader, Action.UpgradePostCheck, mockAI, mockPayload);
+//        status = (Status) Whitebox.getInternalState(upgradePostAction, "status");
+//        Assert.assertEquals("should return invalid parameter",
+//                Integer.valueOf(302), status.getCode());
+//    }
+//    @Test
+//    public void testValidateForUpgradeBackoutAction() throws Exception {
+//        // test commonHeader error
+//        upgradeBackoutAction.validate(mockCommonHeader, Action.UpgradeBackout, mockAI, mockPayload);
+//        Status status = (Status) Whitebox.getInternalState(upgradeBackoutAction, "status");
+//        Assert.assertEquals("should return missing parameter",
+//                Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
+//        //Mockito.verify(upgradeBackoutAction, times(0)).buildStatusForParamName(any(), any());
+//       // Mockito.verify(upgradeBackoutAction, times(0)).buildStatusForErrorMsg(any(), any());
+//
+//        ZULU mockTimeStamp = mock(ZULU.class);
+//        Mockito.doReturn(mockTimeStamp).when(mockCommonHeader).getTimestamp();
+//        Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
+//        Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
+//        Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
+//
+//        // test Invalid action
+//        upgradeBackoutAction.validate(mockCommonHeader, Action.UpgradeBackout, mockAI, mockPayload);
+//        status = (Status) Whitebox.getInternalState(upgradeBackoutAction, "status");
+//        Assert.assertEquals("Should return invalid parameter for action",
+//                Integer.valueOf(302), status.getCode());
+//
+//        // test empty ActionIdentifier
+//        upgradeBackoutAction.validate(mockCommonHeader, Action.UpgradeBackout, mockAI, mockPayload);
+//        status = (Status) Whitebox.getInternalState(upgradeBackoutAction, "status");
+//        Assert.assertEquals("should return missing parameter",
+//                Integer.valueOf(302), status.getCode());
+//
+//        // test empty VSERVER_ID
+//        Mockito.doReturn("").when(mockAI).getVnfId();
+//        upgradeBackoutAction.validate(mockCommonHeader, Action.UpgradeBackout, mockAI, mockPayload);
+//        status = (Status) Whitebox.getInternalState(upgradeBackoutAction, "status");
+//        Assert.assertEquals("should return invalid parameter",
+//                Integer.valueOf(302), status.getCode());
+//
+//        Mockito.doReturn("vnfId").when(mockAI).getVnfId();
+//
+//        // test null payload
+//        upgradeBackoutAction.validate(mockCommonHeader, Action.UpgradeBackout, mockAI, null);
+//       // Mockito.verify(upgradeBackoutAction, times(1)).validateExcludedActIds(any(), any());
+//        status = (Status) Whitebox.getInternalState(upgradeBackoutAction, "status");
+//        Assert.assertEquals("should return missing parameter",
+//                Integer.valueOf(302), status.getCode());
+//
+//        // test empty payload
+//        Mockito.doReturn("").when(mockPayload).getValue();
+//        upgradeBackoutAction.validate(mockCommonHeader, Action.UpgradeBackout, mockAI, mockPayload);
+//        status = (Status) Whitebox.getInternalState(upgradeBackoutAction, "status");
+//        Assert.assertEquals("should return invalid parameter",
+//                Integer.valueOf(302), status.getCode());
+//
+//        // test space payload
+//        Mockito.doReturn(" ").when(mockPayload).getValue();
+//        upgradeBackoutAction.validate(mockCommonHeader, Action.UpgradeBackout, mockAI, mockPayload);
+//        status = (Status) Whitebox.getInternalState(upgradeBackoutAction, "status");
+//        Assert.assertEquals("should return invalid parameter",
+//                Integer.valueOf(302), status.getCode());
+//    }
+//
+//    @Test
+//    public void testValidateForUpgradeSoftwareAction() throws Exception {
+//        // test commonHeader error
+//        upgradeSoftAction.validate(mockCommonHeader, Action.UpgradeSoftware, mockAI, mockPayload);
+//        Status status = (Status) Whitebox.getInternalState(upgradeSoftAction, "status");
+//        Assert.assertEquals("should return missing parameter",
+//                Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
+//        //Mockito.verify(upgradeSoftAction, times(0)).buildStatusForParamName(any(), any());
+//        //Mockito.verify(upgradeSoftAction, times(0)).buildStatusForErrorMsg(any(), any());
+//
+//        ZULU mockTimeStamp = mock(ZULU.class);
+//        Mockito.doReturn(mockTimeStamp).when(mockCommonHeader).getTimestamp();
+//        Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
+//        Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
+//        Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
+//
+//        // test Invalid action
+//        upgradeSoftAction.validate(mockCommonHeader, Action.UpgradeSoftware, mockAI, mockPayload);
+//        status = (Status) Whitebox.getInternalState(upgradeSoftAction, "status");
+//        Assert.assertEquals("Should return invalid parameter for action",
+//                Integer.valueOf(302), status.getCode());
+//
+//        // test empty ActionIdentifier
+//        upgradeSoftAction.validate(mockCommonHeader, Action.UpgradeSoftware, mockAI, mockPayload);
+//        status = (Status) Whitebox.getInternalState(upgradeSoftAction, "status");
+//        Assert.assertEquals("should return missing parameter",
+//                Integer.valueOf(302), status.getCode());
+//
+//        // test empty VSERVER_ID
+//        Mockito.doReturn("").when(mockAI).getVnfId();
+//        upgradeSoftAction.validate(mockCommonHeader, Action.UpgradeSoftware, mockAI, mockPayload);
+//        status = (Status) Whitebox.getInternalState(upgradeSoftAction, "status");
+//        Assert.assertEquals("should return invalid parameter",
+//                Integer.valueOf(302), status.getCode());
+//
+//        Mockito.doReturn("vnfId").when(mockAI).getVnfId();
+//
+//        // test null payload
+//        upgradeSoftAction.validate(mockCommonHeader, Action.UpgradeSoftware, mockAI, null);
+//        //Mockito.verify(upgradeSoftAction, times(1)).validateExcludedActIds(any(), any());
+//        status = (Status) Whitebox.getInternalState(upgradeSoftAction, "status");
+//        Assert.assertEquals("should return missing parameter",
+//                Integer.valueOf(302), status.getCode());
+//
+//        // test empty payload
+//        Mockito.doReturn("").when(mockPayload).getValue();
+//        upgradeSoftAction.validate(mockCommonHeader, Action.UpgradeSoftware, mockAI, mockPayload);
+//        status = (Status) Whitebox.getInternalState(upgradeSoftAction, "status");
+//        Assert.assertEquals("should return invalid parameter",
+//                Integer.valueOf(302), status.getCode());
+//
+//        // test space payload
+//        Mockito.doReturn(" ").when(mockPayload).getValue();
+//        upgradeSoftAction.validate(mockCommonHeader, Action.UpgradeSoftware, mockAI, mockPayload);
+//        status = (Status) Whitebox.getInternalState(upgradeSoftAction, "status");
+//        Assert.assertEquals("should return invalid parameter",
+//                Integer.valueOf(302), status.getCode());
+//    }
+//
+//    @Test
+//    public void testValidateForUpgradeBackupAction() throws Exception {
+//        // test commonHeader error
+//        upgradeBackupAction.validate(mockCommonHeader, Action.UpgradeBackup, mockAI, mockPayload);
+//        Status status = (Status) Whitebox.getInternalState(upgradeBackupAction, "status");
+//        Assert.assertEquals("should return missing parameter",
+//                Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
+//        //Mockito.verify(upgradeBackupAction, times(0)).buildStatusForParamName(any(), any());
+//        //Mockito.verify(upgradeBackupAction, times(0)).buildStatusForErrorMsg(any(), any());
+//
+//        ZULU mockTimeStamp = mock(ZULU.class);
+//        Mockito.doReturn(mockTimeStamp).when(mockCommonHeader).getTimestamp();
+//        Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
+//        Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
+//        Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
+//
+//        // test Invalid action
+//        upgradeBackupAction.validate(mockCommonHeader, Action.UpgradeBackup, mockAI, mockPayload);
+//        status = (Status) Whitebox.getInternalState(upgradeBackupAction, "status");
+//        Assert.assertEquals("Should return invalid parameter for action",
+//                Integer.valueOf(302), status.getCode());
+//
+//        // test empty ActionIdentifier
+//        upgradeBackupAction.validate(mockCommonHeader, Action.UpgradeBackup, mockAI, mockPayload);
+//        status = (Status) Whitebox.getInternalState(upgradeBackupAction, "status");
+//        Assert.assertEquals("should return missing parameter",
+//                Integer.valueOf(302), status.getCode());
+//
+//        // test empty VSERVER_ID
+//        Mockito.doReturn("").when(mockAI).getVnfId();
+//        upgradeBackupAction.validate(mockCommonHeader, Action.UpgradeBackup, mockAI, mockPayload);
+//        status = (Status) Whitebox.getInternalState(upgradeBackupAction, "status");
+//        Assert.assertEquals("should return invalid parameter",
+//                Integer.valueOf(302), status.getCode());
+//
+//        Mockito.doReturn("vnfId").when(mockAI).getVnfId();
+//
+//        // test null payload
+//        upgradeBackupAction.validate(mockCommonHeader, Action.UpgradeBackup, mockAI, null);
+//        //Mockito.verify(upgradeBackupAction, times(1)).validateExcludedActIds(any(), any());
+//        status = (Status) Whitebox.getInternalState(upgradeBackupAction, "status");
+//        Assert.assertEquals("should return missing parameter",
+//                Integer.valueOf(302), status.getCode());
+//
+//        // test empty payload
+//        Mockito.doReturn("").when(mockPayload).getValue();
+//        upgradeBackupAction.validate(mockCommonHeader, Action.UpgradeBackup, mockAI, mockPayload);
+//        status = (Status) Whitebox.getInternalState(upgradeBackupAction, "status");
+//        Assert.assertEquals("should return invalid parameter",
+//                Integer.valueOf(302), status.getCode());
+//
+//        // test space payload
+//        Mockito.doReturn(" ").when(mockPayload).getValue();
+//        upgradeBackupAction.validate(mockCommonHeader, Action.UpgradeBackup, mockAI, mockPayload);
+//        status = (Status) Whitebox.getInternalState(upgradeBackupAction, "status");
+//        Assert.assertEquals("should return invalid parameter",
+//                Integer.valueOf(302), status.getCode());
+//    }
+}
diff --git a/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/service/VolumeServiceTest.java b/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/service/VolumeServiceTest.java
new file mode 100644
index 000000000..0140dabd9
--- /dev/null
+++ b/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/service/VolumeServiceTest.java
@@ -0,0 +1,320 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * ONAP : APPC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * 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
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * 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.lcm.service;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+import org.mockito.internal.util.reflection.Whitebox;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.Action;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AttachVolumeInput;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AttachVolumeOutputBuilder;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.DetachVolumeInput;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.DetachVolumeOutputBuilder;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.Payload;
+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.common.header.CommonHeader;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.status.Status;
+import org.onap.appc.domainmodel.lcm.ResponseContext;
+import org.onap.appc.executor.objects.LCMCommandStatus;
+import org.onap.appc.requesthandler.objects.RequestHandlerOutput;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.powermock.api.mockito.PowerMockito.whenNew;
+
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({VolumeService.class, RequestExecutor.class})
+public class VolumeServiceTest {
+    private final String PAYLOAD_STRING = "{\"A\":\"A-value\",\"B\":{\"C\":\"B.C-value\",\"D\":\"B.D-value\"}}";
+    private AttachVolumeInput mockAttachInput = mock(AttachVolumeInput.class);
+    private DetachVolumeInput mockDetachInput = mock(DetachVolumeInput.class);
+    private CommonHeader mockCommonHeader = mock(CommonHeader.class);
+    private ActionIdentifiers mockAI = mock(ActionIdentifiers.class);
+    private Payload mockPayload = mock(Payload.class);
+
+    private VolumeService volumeServiceForAttachAction;
+    private VolumeService volumeServiceForDetachAction;
+
+    @Before
+    public void setUp() throws Exception {
+        volumeServiceForAttachAction = spy(new VolumeService(true));
+        volumeServiceForDetachAction = spy(new VolumeService(false));
+    }
+
+    @Test
+    public void testConstructor() throws Exception {
+        Action expectedAction = Action.AttachVolume;
+        Assert.assertEquals("Should have proper ACTION", expectedAction,
+            (Action) org.powermock.reflect.Whitebox.getInternalState(volumeServiceForAttachAction, "expectedAction"));
+        Assert.assertEquals("Should have attach-volume RPC name", "attach-volume",
+            (org.powermock.reflect.Whitebox.getInternalState(volumeServiceForAttachAction, "rpcName")).toString());
+
+        expectedAction = Action.DetachVolume;
+        Assert.assertEquals("Should have proper ACTION", expectedAction,
+            (Action) org.powermock.reflect.Whitebox.getInternalState(volumeServiceForDetachAction, "expectedAction"));
+        Assert.assertEquals("Should have detach-volume RPC name","detach-volume",
+            (org.powermock.reflect.Whitebox.getInternalState(volumeServiceForDetachAction, "rpcName")).toString());
+    }
+
+//    @Test
+//    public void testAttachVolume() throws Exception {
+//        // test error occurs in validation
+//        AttachVolumeOutputBuilder outputBuilder = volumeServiceForAttachAction.attachVolume(mockAttachInput);
+//        Mockito.verify(volumeServiceForAttachAction, times(0)).proceedAction(any(), any(), any());
+//        Assert.assertTrue("Should not have commonHeader as we did not mock it",
+//            outputBuilder.getCommonHeader() == null);
+//        Assert.assertEquals("should return missing parameter status",
+//            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()),
+//            outputBuilder.getStatus().getCode());
+//
+//        // make validation pass
+//        Mockito.doReturn(mockCommonHeader).when(mockAttachInput).getCommonHeader();
+//        Mockito.doReturn(mockPayload).when(mockAttachInput).getPayload();
+//        Mockito.doReturn(PAYLOAD_STRING).when(mockPayload).getValue();
+//
+//        ZULU zuluTimeStamp = new ZULU("2017-06-29T21:44:00.35Z");
+//        Mockito.doReturn(zuluTimeStamp).when(mockCommonHeader).getTimestamp();
+//        Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
+//        Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
+//        Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
+//
+//        Mockito.doReturn(Action.AttachVolume).when(mockAttachInput).getAction();
+//        Mockito.doReturn(mockAI).when(mockAttachInput).getActionIdentifiers();
+//        Mockito.doReturn("vserverId").when(mockAI).getVserverId();
+
+        // test proceedAction return with error
+//        outputBuilder = volumeServiceForAttachAction.attachVolume(mockAttachInput);
+//        Mockito.verify(volumeServiceForAttachAction, times(1)).proceedAction(any(), any(), any());
+//        Assert.assertTrue("Should have commonHeader",
+//            outputBuilder.getCommonHeader() != null);
+//        Assert.assertEquals("should return rejected status",
+//            Integer.valueOf(LCMCommandStatus.REJECTED.getResponseCode()),
+//            outputBuilder.getStatus().getCode());
+
+        // test proceedAction return without error
+//        RequestExecutor mockExecutor = mock(RequestExecutor.class);
+//        whenNew(RequestExecutor.class).withNoArguments().thenReturn(mockExecutor);
+//
+//        RequestHandlerOutput mockOutput = mock(RequestHandlerOutput.class);
+//        Mockito.doReturn(mockOutput).when(mockExecutor).executeRequest(any());
+//
+//        ResponseContext mockResponseContext = mock(ResponseContext.class);
+//        Mockito.doReturn(mockResponseContext).when(mockOutput).getResponseContext();
+//
+//        org.onap.appc.domainmodel.lcm.Status mockStatus = mock(org.onap.appc.domainmodel.lcm.Status.class);
+//        Integer successCode = Integer.valueOf(LCMCommandStatus.SUCCESS.getResponseCode());
+//        Mockito.doReturn(successCode).when(mockStatus).getCode();
+//        Mockito.doReturn(mockStatus).when(mockResponseContext).getStatus();
+//
+//        outputBuilder = volumeServiceForAttachAction.attachVolume(mockAttachInput);
+//        Assert.assertTrue("Should have commonHeader",
+//            outputBuilder.getCommonHeader() != null);
+//        Assert.assertEquals("should return success status",
+//            successCode, outputBuilder.getStatus().getCode());
+//    }
+
+//    @Test
+//    public void testDetachVolumn() throws Exception {
+//        // test error occurs in validation
+//        DetachVolumeOutputBuilder outputBuilder = volumeServiceForDetachAction.detachVolume(mockDetachInput);
+//        Mockito.verify(volumeServiceForDetachAction, times(0)).proceedAction(any(), any(), any());
+//        Assert.assertTrue("Should not have commonHeader as we did not mock it",
+//            outputBuilder.getCommonHeader() == null);
+//        Assert.assertEquals("should return missing parameter status",
+//            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()),
+//            outputBuilder.getStatus().getCode());
+//
+//        // make validation pass
+//        Mockito.doReturn(mockCommonHeader).when(mockDetachInput).getCommonHeader();
+//        Mockito.doReturn(mockPayload).when(mockDetachInput).getPayload();
+//        Mockito.doReturn(PAYLOAD_STRING).when(mockPayload).getValue();
+//
+//        ZULU zuluTimeStamp = new ZULU("2017-06-29T21:44:00.35Z");
+//        Mockito.doReturn(zuluTimeStamp).when(mockCommonHeader).getTimestamp();
+//        Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
+//        Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
+//        Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
+//
+//        Mockito.doReturn(Action.DetachVolume).when(mockDetachInput).getAction();
+//        Mockito.doReturn(mockAI).when(mockDetachInput).getActionIdentifiers();
+//        Mockito.doReturn("vserverId").when(mockAI).getVserverId();
+
+        // test proceedAction return with error
+//        outputBuilder = volumeServiceForDetachAction.detachVolume(mockDetachInput);
+//        Mockito.verify(volumeServiceForDetachAction, times(1)).proceedAction(any(), any(), any());
+//        Assert.assertTrue("Should have commonHeader",
+//            outputBuilder.getCommonHeader() != null);
+//        Assert.assertEquals("should return rejected status",
+//            Integer.valueOf(LCMCommandStatus.REJECTED.getResponseCode()),
+//            outputBuilder.getStatus().getCode());
+
+        // test proceedAction return without error
+//        RequestExecutor mockExecutor = mock(RequestExecutor.class);
+//        whenNew(RequestExecutor.class).withNoArguments().thenReturn(mockExecutor);
+//
+//        RequestHandlerOutput mockOutput = mock(RequestHandlerOutput.class);
+//        Mockito.doReturn(mockOutput).when(mockExecutor).executeRequest(any());
+//
+//        ResponseContext mockResponseContext = mock(ResponseContext.class);
+//        Mockito.doReturn(mockResponseContext).when(mockOutput).getResponseContext();
+//
+//        org.onap.appc.domainmodel.lcm.Status mockStatus = mock(org.onap.appc.domainmodel.lcm.Status.class);
+//        Integer successCode = Integer.valueOf(LCMCommandStatus.SUCCESS.getResponseCode());
+//        Mockito.doReturn(successCode).when(mockStatus).getCode();
+//        Mockito.doReturn(mockStatus).when(mockResponseContext).getStatus();;
+//
+//        outputBuilder = volumeServiceForDetachAction.detachVolume(mockDetachInput);
+//        Assert.assertTrue("Should have commonHeader",
+//            outputBuilder.getCommonHeader() != null);
+//        Assert.assertEquals("should return success status",
+//            successCode, outputBuilder.getStatus().getCode());
+//    }
+
+    @Test
+    public void testValidateForAttachAction() throws Exception {
+        // test commonHeader error
+        volumeServiceForAttachAction.validate(mockCommonHeader, Action.AttachVolume, mockAI, mockPayload);
+        Status status = (Status) Whitebox.getInternalState(volumeServiceForAttachAction, "status");
+        Assert.assertEquals("should return missing parameter",
+            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
+        Mockito.verify(volumeServiceForDetachAction, times(0)).buildStatusForParamName(any(), any());
+        Mockito.verify(volumeServiceForDetachAction, times(0)).buildStatusForErrorMsg(any(), any());
+
+        ZULU mockTimeStamp = mock(ZULU.class);
+        Mockito.doReturn(mockTimeStamp).when(mockCommonHeader).getTimestamp();
+        Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
+        Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
+        Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
+
+        // test Invalid action
+        volumeServiceForAttachAction.validate(mockCommonHeader, Action.DetachVolume, mockAI, mockPayload);
+        status = (Status) Whitebox.getInternalState(volumeServiceForAttachAction, "status");
+        Assert.assertEquals("Should return invalid parameter for action",
+            Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());
+
+        // test empty ActionIdentifier
+        volumeServiceForAttachAction.validate(mockCommonHeader, Action.AttachVolume, mockAI, mockPayload);
+        status = (Status) Whitebox.getInternalState(volumeServiceForAttachAction, "status");
+        Assert.assertEquals("should return missing parameter",
+            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
+
+        // test empty VSERVER_ID
+        Mockito.doReturn("").when(mockAI).getVserverId();
+        volumeServiceForAttachAction.validate(mockCommonHeader, Action.AttachVolume, mockAI, mockPayload);
+        status = (Status) Whitebox.getInternalState(volumeServiceForAttachAction, "status");
+        Assert.assertEquals("should return invalid parameter",
+            Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());
+
+        Mockito.doReturn("vserverId").when(mockAI).getVserverId();
+
+        // test null payload
+        volumeServiceForAttachAction.validate(mockCommonHeader, Action.AttachVolume, mockAI, null);
+        Mockito.verify(volumeServiceForAttachAction, times(1)).validateExcludedActIds(any(), any());
+        status = (Status) Whitebox.getInternalState(volumeServiceForAttachAction, "status");
+        Assert.assertEquals("should return missing parameter",
+            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
+
+        // test empty payload
+        Mockito.doReturn("").when(mockPayload).getValue();
+        volumeServiceForAttachAction.validate(mockCommonHeader, Action.AttachVolume, mockAI, mockPayload);
+        status = (Status) Whitebox.getInternalState(volumeServiceForAttachAction, "status");
+        Assert.assertEquals("should return invalid parameter",
+            Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());
+
+        // test space payload
+        Mockito.doReturn(" ").when(mockPayload).getValue();
+        volumeServiceForAttachAction.validate(mockCommonHeader, Action.AttachVolume, mockAI, mockPayload);
+        status = (Status) Whitebox.getInternalState(volumeServiceForAttachAction, "status");
+        Assert.assertEquals("should return invalid parameter",
+            Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());
+    }
+
+    @Test
+    public void testValidateForDetachAction() throws Exception {
+        // test commonHeader error
+        volumeServiceForDetachAction.validate(mockCommonHeader, Action.DetachVolume, mockAI, mockPayload);
+        Status status = (Status) Whitebox.getInternalState(volumeServiceForDetachAction, "status");
+        Assert.assertEquals("should return missing parameter",
+            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
+        Mockito.verify(volumeServiceForDetachAction, times(0)).buildStatusForParamName(any(), any());
+        Mockito.verify(volumeServiceForDetachAction, times(0)).buildStatusForErrorMsg(any(), any());
+
+        ZULU mockTimeStamp = mock(ZULU.class);
+        Mockito.doReturn(mockTimeStamp).when(mockCommonHeader).getTimestamp();
+        Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
+        Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
+        Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
+
+        // test Invalid action
+        volumeServiceForDetachAction.validate(mockCommonHeader, Action.AttachVolume, mockAI, mockPayload);
+        status = (Status) Whitebox.getInternalState(volumeServiceForDetachAction, "status");
+        Assert.assertEquals("Should return invalid parameter for action",
+            Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());
+
+        // test empty ActionIdentifier
+        volumeServiceForDetachAction.validate(mockCommonHeader, Action.DetachVolume, mockAI, mockPayload);
+        status = (Status) Whitebox.getInternalState(volumeServiceForDetachAction, "status");
+        Assert.assertEquals("should return missing parameter",
+            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
+
+        // test empty VSERVER_ID
+        Mockito.doReturn("").when(mockAI).getVserverId();
+        volumeServiceForDetachAction.validate(mockCommonHeader, Action.DetachVolume, mockAI, mockPayload);
+        status = (Status) Whitebox.getInternalState(volumeServiceForDetachAction, "status");
+        Assert.assertEquals("should return invalid parameter",
+            Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());
+
+        Mockito.doReturn("vserverId").when(mockAI).getVserverId();
+
+        // test null payload
+        volumeServiceForDetachAction.validate(mockCommonHeader, Action.DetachVolume, mockAI, null);
+        Mockito.verify(volumeServiceForDetachAction, times(1)).validateExcludedActIds(any(), any());
+        status = (Status) Whitebox.getInternalState(volumeServiceForDetachAction, "status");
+        Assert.assertEquals("should return missing parameter",
+            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
+
+        // test empty payload
+        Mockito.doReturn("").when(mockPayload).getValue();
+        volumeServiceForDetachAction.validate(mockCommonHeader, Action.DetachVolume, mockAI, mockPayload);
+        status = (Status) Whitebox.getInternalState(volumeServiceForDetachAction, "status");
+        Assert.assertEquals("should return invalid parameter",
+            Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());
+
+        // test space payload
+        Mockito.doReturn(" ").when(mockPayload).getValue();
+        volumeServiceForDetachAction.validate(mockCommonHeader, Action.DetachVolume, mockAI, mockPayload);
+        status = (Status) Whitebox.getInternalState(volumeServiceForDetachAction, "status");
+        Assert.assertEquals("should return invalid parameter",
+            Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()), status.getCode());
+    }
+}
diff --git a/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/util/ValidationServiceTest.java b/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/util/ValidationServiceTest.java
new file mode 100644
index 000000000..ed2adf3de
--- /dev/null
+++ b/appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/util/ValidationServiceTest.java
@@ -0,0 +1,89 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * ONAP : APPC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * 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
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * 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.lcm.util;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.Action;
+import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ZULU;
+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.status.Status;
+import org.onap.appc.executor.objects.LCMCommandStatus;
+
+import static org.mockito.Mockito.mock;
+
+public class ValidationServiceTest {
+    private final Integer expectedErrorCode = Integer.valueOf(
+        LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode());
+    @Before
+    public void setUp() throws Exception {
+    }
+
+    @Test
+    public void getInstance() throws Exception {
+        Assert.assertEquals("Should always return the same instance",
+            ValidationService.getInstance(), ValidationService.getInstance());
+    }
+
+    @Test
+    public void validateInput() throws Exception {
+        Status status = ValidationService.getInstance().validateInput(null, null, null);
+        Assert.assertEquals("Should return error status", expectedErrorCode, status.getCode());
+        Assert.assertTrue("Should include common-header in the message",
+            status.getMessage().contains("common-header"));
+        Assert.assertTrue("Should include action in the message",
+            status.getMessage().contains("action"));
+
+        CommonHeader mockCommonHeader = mock(CommonHeader.class);
+        status = ValidationService.getInstance().validateInput(mockCommonHeader, Action.Query, "query");
+        Assert.assertEquals("Should return error status", expectedErrorCode, status.getCode());
+        Assert.assertFalse("Should not include action in the message",
+            status.getMessage().contains("action"));
+
+        Mockito.when(mockCommonHeader.getApiVer()).thenReturn("testing API version");
+        status = ValidationService.getInstance().validateInput(mockCommonHeader, Action.Query, "query");
+        Assert.assertEquals("Should return error status", expectedErrorCode, status.getCode());
+        Assert.assertFalse("Should not include api-ver in the message",
+            status.getMessage().contains("api-ver"));
+
+        Mockito.when(mockCommonHeader.getOriginatorId()).thenReturn("testing originator id");
+        status = ValidationService.getInstance().validateInput(mockCommonHeader, Action.Query, "query");
+        Assert.assertEquals("Should return error status", expectedErrorCode, status.getCode());
+        Assert.assertFalse("Should not include originator-id in the message",
+            status.getMessage().contains("originator-id"));
+
+        Mockito.when(mockCommonHeader.getRequestId()).thenReturn("testing request id");
+        status = ValidationService.getInstance().validateInput(mockCommonHeader, Action.Query, "query");
+        Assert.assertEquals("Should return error status", expectedErrorCode, status.getCode());
+        Assert.assertFalse("Should not include request-id in the message",
+            status.getMessage().contains("request-id"));
+
+        Mockito.when(mockCommonHeader.getTimestamp()).thenReturn(mock(ZULU.class));
+        status = ValidationService.getInstance().validateInput(mockCommonHeader, Action.Query, "query");
+        Assert.assertTrue("Should return success", status == null);
+    }
+}