appc-provider/appc-provider-bundle/src/test/java/org/onap/appc/provider/lcm/service/UpgradeServiceTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP : APPC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Copyright (C) 2017 Amdocs
   8  * =============================================================================
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  * ECOMP is a trademark and service mark of AT&T Intellectual Property.
  22  * ============LICENSE_END=========================================================
  23  */
  24
  25 package org.onap.appc.provider.lcm.service;
  26
  27 import org.junit.Assert;
  28 import org.junit.Before;
  29 import org.junit.Test;
  30 import org.junit.runner.RunWith;
  31 import org.mockito.Mockito;
  32 import org.mockito.internal.util.reflection.Whitebox;
  33 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.*;
  34 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.action.identifiers.ActionIdentifiers;
  35 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.common.header.CommonHeader;
  36 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.status.Status;
  37 import org.onap.appc.domainmodel.lcm.ResponseContext;
  38 import org.onap.appc.executor.objects.LCMCommandStatus;
  39 import org.onap.appc.requesthandler.objects.RequestHandlerOutput;
  40 import org.powermock.core.classloader.annotations.PrepareForTest;
  41 import org.powermock.modules.junit4.PowerMockRunner;
  42
  43 import static org.mockito.Matchers.any;
  44 import static org.mockito.Mockito.*;
  45 import static org.powermock.api.mockito.PowerMockito.whenNew;
  46
  47 @RunWith(PowerMockRunner.class)
  48 @PrepareForTest({UpgradeService.class, RequestExecutor.class})
  49 public class UpgradeServiceTest {
  50     private final String PAYLOAD_STRING = "{\"A\":\"A-value\",\"B\":{\"C\":\"B.C-value\",\"D\":\"B.D-value\"}}";
  51     private UpgradePreCheckInput mockUpgradePreInput = mock(UpgradePreCheckInput.class);
  52     private UpgradePostCheckInput mockUpgradePostInput = mock(UpgradePostCheckInput.class);
  53     private UpgradeSoftwareInput mockUpgradeSoftInput = mock(UpgradeSoftwareInput.class);
  54     private UpgradeBackupInput mockUpgradeBackupInput = mock(UpgradeBackupInput.class);
  55     private UpgradeBackoutInput mockUpgradeBackoutInput = mock(UpgradeBackoutInput.class);
  56     private CommonHeader mockCommonHeader = mock(CommonHeader.class);
  57     private ActionIdentifiers mockAI = mock(ActionIdentifiers.class);
  58     private Payload mockPayload = mock(Payload.class);
  59
  60     private UpgradeService upgradePreAction;
  61     private UpgradeService upgradePostAction;
  62     private UpgradeService upgradeSoftAction;
  63     private UpgradeService upgradeBackupAction;
  64     private UpgradeService upgradeBackoutAction;
  65
  66     @Before
  67     public void setUp() throws Exception {
  68         upgradePreAction = spy(new UpgradeService("upgradePre"));
  69         upgradePostAction = spy(new UpgradeService("upgradePost"));
  70         upgradeSoftAction = spy(new UpgradeService("upgradeSoft"));
  71         upgradeBackupAction = spy(new UpgradeService("upgradeBackup"));
  72         upgradeBackoutAction = spy(new UpgradeService("upgradeBackout"));
  73     }
  74
  75     @Test
  76     public void testConstructor() throws Exception {
  77         Action expectedAction = Action.UpgradePreCheck;
  78         Assert.assertEquals("Should have proper ACTION", expectedAction,
  79             (Action) org.powermock.reflect.Whitebox.getInternalState(upgradePreAction, "expectedAction"));
  80         Assert.assertEquals("Should have upgrade-precheck RPC name", "upgrade-pre-check",
  81             (org.powermock.reflect.Whitebox.getInternalState(upgradePreAction, "rpcName")).toString());
  82
  83         expectedAction = Action.UpgradePostCheck;
  84         Assert.assertEquals("Should have proper ACTION", expectedAction,
  85             (Action) org.powermock.reflect.Whitebox.getInternalState(upgradePostAction, "expectedAction"));
  86         Assert.assertEquals("Should have upgrade-postcheck RPC name","upgrade-post-check",
  87             (org.powermock.reflect.Whitebox.getInternalState(upgradePostAction, "rpcName")).toString());
  88
  89          expectedAction = Action.UpgradeSoftware;
  90         Assert.assertEquals("Should have proper ACTION", expectedAction,
  91                 (Action) org.powermock.reflect.Whitebox.getInternalState(upgradeSoftAction, "expectedAction"));
  92         Assert.assertEquals("Should have upgrade-software RPC name", "upgrade-software",
  93                 (org.powermock.reflect.Whitebox.getInternalState(upgradeSoftAction, "rpcName")).toString());
  94
  95         expectedAction = Action.UpgradeBackup;
  96         Assert.assertEquals("Should have proper ACTION", expectedAction,
  97                 (Action) org.powermock.reflect.Whitebox.getInternalState(upgradeBackupAction, "expectedAction"));
  98         Assert.assertEquals("Should have upgrade-backup RPC name","upgrade-backup",
  99                 (org.powermock.reflect.Whitebox.getInternalState(upgradeBackupAction, "rpcName")).toString());
 100
 101         expectedAction = Action.UpgradeBackout;
 102         Assert.assertEquals("Should have proper ACTION", expectedAction,
 103                 (Action) org.powermock.reflect.Whitebox.getInternalState(upgradeBackoutAction, "expectedAction"));
 104         Assert.assertEquals("Should have upgrade-backout RPC name","upgrade-backout",
 105                 (org.powermock.reflect.Whitebox.getInternalState(upgradeBackoutAction, "rpcName")).toString());
 106
 107     }
 108
 109 //    @Test
 110 //    public void testUpgradePreCheck() throws Exception {
 111 //        // test error occurs in validation
 112 //        UpgradePreCheckOutputBuilder outputBuilder = upgradePreAction.upgradePreCheck(mockUpgradePreInput);
 113 //        //Mockito.verify(upgradePreAction, times(0)).proceedAction(any(), any(), any());
 114 //        Assert.assertTrue("Should not have commonHeader as we did not mock it",
 115 //            outputBuilder.getCommonHeader() == null);
 116 //        Assert.assertEquals("should return missing parameter status",
 117 //            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()),
 118 //            outputBuilder.getStatus().getCode());
 119 //
 120 //        // make validation pass
 121 //        Mockito.doReturn(mockCommonHeader).when(mockUpgradePreInput).getCommonHeader();
 122 //        Mockito.doReturn(mockPayload).when(mockUpgradePreInput).getPayload();
 123 //        Mockito.doReturn(PAYLOAD_STRING).when(mockPayload).getValue();
 124 //
 125 //        ZULU zuluTimeStamp = new ZULU("2017-06-29T21:44:00.35Z");
 126 //        Mockito.doReturn(zuluTimeStamp).when(mockCommonHeader).getTimestamp();
 127 //        Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
 128 //        Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
 129 //        Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
 130 //
 131 //        Mockito.doReturn(Action.UpgradePreCheck).when(mockUpgradePreInput).getAction();
 132 //        Mockito.doReturn(mockAI).when(mockUpgradePreInput).getActionIdentifiers();
 133 //        Mockito.doReturn("vnfId").when(mockAI).getVnfId();
 134 //
 135 //        // test proceedAction return with error
 136 //        outputBuilder = upgradePreAction.upgradePreCheck(mockUpgradePreInput);
 137 //        //Mockito.verify(upgradePreAction, times(1)).proceedAction(any(), any(), any());
 138 //        Assert.assertTrue("Should have commonHeader",
 139 //            outputBuilder.getCommonHeader() != null);
 140 //        Assert.assertEquals("should return rejected status",
 141 //            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()),
 142 //            outputBuilder.getStatus().getCode());
 143 //
 144 //        // test proceedAction return without error
 145 //        RequestExecutor mockExecutor = mock(RequestExecutor.class);
 146 //        whenNew(RequestExecutor.class).withNoArguments().thenReturn(mockExecutor);
 147 //
 148 //        RequestHandlerOutput mockOutput = mock(RequestHandlerOutput.class);
 149 //        Mockito.doReturn(mockOutput).when(mockExecutor).executeRequest(any());
 150 //
 151 //        ResponseContext mockResponseContext = mock(ResponseContext.class);
 152 //        Mockito.doReturn(mockResponseContext).when(mockOutput).getResponseContext();
 153 //
 154 //        org.onap.appc.domainmodel.lcm.Status mockStatus = mock(org.onap.appc.domainmodel.lcm.Status.class);
 155 //        Integer successCode = Integer.valueOf(LCMCommandStatus.SUCCESS.getResponseCode());
 156 //        Mockito.doReturn(successCode).when(mockStatus).getCode();
 157 //        Mockito.doReturn(mockStatus).when(mockResponseContext).getStatus();
 158 //
 159 //        outputBuilder = upgradePreAction.upgradePreCheck(mockUpgradePreInput);
 160 //        Assert.assertTrue("Should have commonHeader",
 161 //            outputBuilder.getCommonHeader() != null);
 162 //        Assert.assertEquals("should return success status",
 163 //            new Integer(302), outputBuilder.getStatus().getCode());
 164 //    }
 165 //
 166 //    @Test
 167 //    public void testUpgradePostCheck() throws Exception {
 168 //        // test error occurs in validation
 169 //        UpgradePostCheckOutputBuilder outputBuilder = upgradePostAction.upgradePostCheck(mockUpgradePostInput);
 170 //       // Mockito.verify(upgradePostAction, times(0)).proceedAction(any(), any(), any());
 171 //        Assert.assertTrue("Should not have commonHeader as we did not mock it",
 172 //            outputBuilder.getCommonHeader() == null);
 173 //        Assert.assertEquals("should return missing parameter status",
 174 //            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()),
 175 //            outputBuilder.getStatus().getCode());
 176 //
 177 //        // make validation pass
 178 //        Mockito.doReturn(mockCommonHeader).when(mockUpgradePostInput).getCommonHeader();
 179 //        Mockito.doReturn(mockPayload).when(mockUpgradePostInput).getPayload();
 180 //        Mockito.doReturn(PAYLOAD_STRING).when(mockPayload).getValue();
 181 //
 182 //        ZULU zuluTimeStamp = new ZULU("2017-06-29T21:44:00.35Z");
 183 //        Mockito.doReturn(zuluTimeStamp).when(mockCommonHeader).getTimestamp();
 184 //        Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
 185 //        Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
 186 //        Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
 187 //
 188 //        Mockito.doReturn(Action.UpgradePostCheck).when(mockUpgradePostInput).getAction();
 189 //        Mockito.doReturn(mockAI).when(mockUpgradePostInput).getActionIdentifiers();
 190 //        Mockito.doReturn("vnfId").when(mockAI).getVnfId();
 191 //
 192 //        // test proceedAction return with error
 193 //        outputBuilder = upgradePostAction.upgradePostCheck(mockUpgradePostInput);
 194 //       // Mockito.verify(upgradePostAction, times(1)).proceedAction(any(), any(), any());
 195 //        Assert.assertTrue("Should have commonHeader",
 196 //            outputBuilder.getCommonHeader() != null);
 197 //        Assert.assertEquals("should return rejected status",
 198 //            Integer.valueOf(302),
 199 //            outputBuilder.getStatus().getCode());
 200 //
 201 //        // test proceedAction return without error
 202 //        RequestExecutor mockExecutor = mock(RequestExecutor.class);
 203 //        whenNew(RequestExecutor.class).withNoArguments().thenReturn(mockExecutor);
 204 //
 205 //        RequestHandlerOutput mockOutput = mock(RequestHandlerOutput.class);
 206 //        Mockito.doReturn(mockOutput).when(mockExecutor).executeRequest(any());
 207 //
 208 //        ResponseContext mockResponseContext = mock(ResponseContext.class);
 209 //        Mockito.doReturn(mockResponseContext).when(mockOutput).getResponseContext();
 210 //
 211 //        org.onap.appc.domainmodel.lcm.Status mockStatus = mock(org.onap.appc.domainmodel.lcm.Status.class);
 212 //        Integer successCode = Integer.valueOf(LCMCommandStatus.SUCCESS.getResponseCode());
 213 //        Mockito.doReturn(successCode).when(mockStatus).getCode();
 214 //        Mockito.doReturn(mockStatus).when(mockResponseContext).getStatus();;
 215 //
 216 //        outputBuilder = upgradePostAction.upgradePostCheck(mockUpgradePostInput);
 217 //        Assert.assertTrue("Should have commonHeader",
 218 //            outputBuilder.getCommonHeader() != null);
 219 //        Assert.assertEquals("should return success status",
 220 //                new Integer(302), outputBuilder.getStatus().getCode());
 221 //    }
 222 //    @Test
 223 //    public void testUpgradeSoftware() throws Exception {
 224 //        // test error occurs in validation
 225 //        UpgradeSoftwareOutputBuilder outputBuilder = upgradeSoftAction.upgradeSoftware(mockUpgradeSoftInput);
 226 //        //Mockito.verify(upgradeSoftAction, times(0)).proceedAction(any(), any(), any());
 227 //        Assert.assertTrue("Should not have commonHeader as we did not mock it",
 228 //                outputBuilder.getCommonHeader() == null);
 229 //        Assert.assertEquals("should return missing parameter status",
 230 //                Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()),
 231 //                outputBuilder.getStatus().getCode());
 232 //
 233 //        // make validation pass
 234 //        Mockito.doReturn(mockCommonHeader).when(mockUpgradeSoftInput).getCommonHeader();
 235 //        Mockito.doReturn(mockPayload).when(mockUpgradeSoftInput).getPayload();
 236 //        Mockito.doReturn(PAYLOAD_STRING).when(mockPayload).getValue();
 237 //
 238 //        ZULU zuluTimeStamp = new ZULU("2017-06-29T21:44:00.35Z");
 239 //        Mockito.doReturn(zuluTimeStamp).when(mockCommonHeader).getTimestamp();
 240 //        Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
 241 //        Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
 242 //        Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
 243 //
 244 //        Mockito.doReturn(Action.UpgradeSoftware).when(mockUpgradeSoftInput).getAction();
 245 //        Mockito.doReturn(mockAI).when(mockUpgradeSoftInput).getActionIdentifiers();
 246 //        Mockito.doReturn("vnfId").when(mockAI).getVnfId();
 247 //
 248 //        // test proceedAction return with error
 249 //        outputBuilder = upgradeSoftAction.upgradeSoftware(mockUpgradeSoftInput);
 250 //        //Mockito.verify(upgradeSoftAction, times(1)).proceedAction(any(), any(), any());
 251 //        Assert.assertTrue("Should have commonHeader",
 252 //                outputBuilder.getCommonHeader() != null);
 253 //        Assert.assertEquals("should return rejected status",
 254 //                Integer.valueOf(302),
 255 //                outputBuilder.getStatus().getCode());
 256 //
 257 //        // test proceedAction return without error
 258 //        RequestExecutor mockExecutor = mock(RequestExecutor.class);
 259 //        whenNew(RequestExecutor.class).withNoArguments().thenReturn(mockExecutor);
 260 //
 261 //        RequestHandlerOutput mockOutput = mock(RequestHandlerOutput.class);
 262 //        Mockito.doReturn(mockOutput).when(mockExecutor).executeRequest(any());
 263 //
 264 //        ResponseContext mockResponseContext = mock(ResponseContext.class);
 265 //        Mockito.doReturn(mockResponseContext).when(mockOutput).getResponseContext();
 266 //
 267 //        org.onap.appc.domainmodel.lcm.Status mockStatus = mock(org.onap.appc.domainmodel.lcm.Status.class);
 268 //        Integer successCode = Integer.valueOf(LCMCommandStatus.SUCCESS.getResponseCode());
 269 //        Mockito.doReturn(successCode).when(mockStatus).getCode();
 270 //        Mockito.doReturn(mockStatus).when(mockResponseContext).getStatus();
 271 //
 272 //        outputBuilder = upgradeSoftAction.upgradeSoftware(mockUpgradeSoftInput);
 273 //        Assert.assertTrue("Should have commonHeader",
 274 //                outputBuilder.getCommonHeader() != null);
 275 //        Assert.assertEquals("should return success status",
 276 //                new Integer(302), outputBuilder.getStatus().getCode());
 277 //    }
 278 //    @Test
 279 //    public void testUpgradeBackup() throws Exception {
 280 //        // test error occurs in validation
 281 //        UpgradeBackupOutputBuilder outputBuilder = upgradeBackupAction.upgradeBackup(mockUpgradeBackupInput);
 282 //        //Mockito.verify(upgradeBackupAction, times(0)).proceedAction(any(), any(), any());
 283 //        Assert.assertTrue("Should not have commonHeader as we did not mock it",
 284 //                outputBuilder.getCommonHeader() == null);
 285 //        Assert.assertEquals("should return missing parameter status",
 286 //                Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()),
 287 //                outputBuilder.getStatus().getCode());
 288 //
 289 //        // make validation pass
 290 //        Mockito.doReturn(mockCommonHeader).when(mockUpgradeBackupInput).getCommonHeader();
 291 //        Mockito.doReturn(mockPayload).when(mockUpgradeBackupInput).getPayload();
 292 //        Mockito.doReturn(PAYLOAD_STRING).when(mockPayload).getValue();
 293 //
 294 //        ZULU zuluTimeStamp = new ZULU("2017-06-29T21:44:00.35Z");
 295 //        Mockito.doReturn(zuluTimeStamp).when(mockCommonHeader).getTimestamp();
 296 //        Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
 297 //        Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
 298 //        Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
 299 //
 300 //        Mockito.doReturn(Action.UpgradeBackup).when(mockUpgradeBackupInput).getAction();
 301 //        Mockito.doReturn(mockAI).when(mockUpgradeBackupInput).getActionIdentifiers();
 302 //        Mockito.doReturn("vnfId").when(mockAI).getVnfId();
 303 //
 304 //        // test proceedAction return with error
 305 //        outputBuilder = upgradeBackupAction.upgradeBackup(mockUpgradeBackupInput);
 306 //        //Mockito.verify(upgradeBackupAction, times(1)).proceedAction(any(), any(), any());
 307 //        Assert.assertTrue("Should have commonHeader",
 308 //                outputBuilder.getCommonHeader() != null);
 309 //        Assert.assertEquals("should return rejected status",
 310 //                Integer.valueOf(302),
 311 //                outputBuilder.getStatus().getCode());
 312 //
 313 //        // test proceedAction return without error
 314 //        RequestExecutor mockExecutor = mock(RequestExecutor.class);
 315 //        whenNew(RequestExecutor.class).withNoArguments().thenReturn(mockExecutor);
 316 //
 317 //        RequestHandlerOutput mockOutput = mock(RequestHandlerOutput.class);
 318 //        Mockito.doReturn(mockOutput).when(mockExecutor).executeRequest(any());
 319 //
 320 //        ResponseContext mockResponseContext = mock(ResponseContext.class);
 321 //        Mockito.doReturn(mockResponseContext).when(mockOutput).getResponseContext();
 322 //
 323 //        org.onap.appc.domainmodel.lcm.Status mockStatus = mock(org.onap.appc.domainmodel.lcm.Status.class);
 324 //        Integer successCode = Integer.valueOf(LCMCommandStatus.SUCCESS.getResponseCode());
 325 //        Mockito.doReturn(successCode).when(mockStatus).getCode();
 326 //        Mockito.doReturn(mockStatus).when(mockResponseContext).getStatus();
 327 //
 328 //        outputBuilder = upgradeBackupAction.upgradeBackup(mockUpgradeBackupInput);
 329 //        Assert.assertTrue("Should have commonHeader",
 330 //                outputBuilder.getCommonHeader() != null);
 331 //        Assert.assertEquals("should return success status",
 332 //                new Integer(302), outputBuilder.getStatus().getCode());
 333 //    }
 334 //
 335 //    @Test
 336 //    public void testUpgradeBackout() throws Exception {
 337 //        // test error occurs in validation
 338 //        UpgradeBackoutOutputBuilder outputBuilder = upgradeBackoutAction.upgradeBackout(mockUpgradeBackoutInput);
 339 //        //Mockito.verify(upgradeBackoutAction, times(0)).proceedAction(any(), any(), any());
 340 //        Assert.assertTrue("Should not have commonHeader as we did not mock it",
 341 //                outputBuilder.getCommonHeader() == null);
 342 //        Assert.assertEquals("should return missing parameter status",
 343 //                Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()),
 344 //                outputBuilder.getStatus().getCode());
 345 //
 346 //        // make validation pass
 347 //        Mockito.doReturn(mockCommonHeader).when(mockUpgradeBackoutInput).getCommonHeader();
 348 //        Mockito.doReturn(mockPayload).when(mockUpgradeBackoutInput).getPayload();
 349 //        Mockito.doReturn(PAYLOAD_STRING).when(mockPayload).getValue();
 350 //
 351 //        ZULU zuluTimeStamp = new ZULU("2017-06-29T21:44:00.35Z");
 352 //        Mockito.doReturn(zuluTimeStamp).when(mockCommonHeader).getTimestamp();
 353 //        Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
 354 //        Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
 355 //        Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
 356 //
 357 //        Mockito.doReturn(Action.UpgradeBackup).when(mockUpgradeBackupInput).getAction();
 358 //        Mockito.doReturn(mockAI).when(mockUpgradeBackupInput).getActionIdentifiers();
 359 //        Mockito.doReturn("vnfId").when(mockAI).getVnfId();
 360 //
 361 //        // test proceedAction return with error
 362 //        outputBuilder = upgradeBackoutAction.upgradeBackout(mockUpgradeBackoutInput);
 363 //        //Mockito.verify(upgradeBackoutAction, times(1)).proceedAction(any(), any(), any());
 364 //        Assert.assertTrue("Should have commonHeader",
 365 //                outputBuilder.getCommonHeader() != null);
 366 //        Assert.assertEquals("should return rejected status",
 367 //                Integer.valueOf(302),
 368 //                outputBuilder.getStatus().getCode());
 369 //
 370 //        // test proceedAction return without error
 371 //        RequestExecutor mockExecutor = mock(RequestExecutor.class);
 372 //        whenNew(RequestExecutor.class).withNoArguments().thenReturn(mockExecutor);
 373 //
 374 //        RequestHandlerOutput mockOutput = mock(RequestHandlerOutput.class);
 375 //        Mockito.doReturn(mockOutput).when(mockExecutor).executeRequest(any());
 376 //
 377 //        ResponseContext mockResponseContext = mock(ResponseContext.class);
 378 //        Mockito.doReturn(mockResponseContext).when(mockOutput).getResponseContext();
 379 //
 380 //        org.onap.appc.domainmodel.lcm.Status mockStatus = mock(org.onap.appc.domainmodel.lcm.Status.class);
 381 //        Integer successCode = Integer.valueOf(LCMCommandStatus.SUCCESS.getResponseCode());
 382 //        Mockito.doReturn(successCode).when(mockStatus).getCode();
 383 //        Mockito.doReturn(mockStatus).when(mockResponseContext).getStatus();
 384 //
 385 //        outputBuilder = upgradeBackoutAction.upgradeBackout(mockUpgradeBackoutInput);
 386 //        Assert.assertTrue("Should have commonHeader",
 387 //                outputBuilder.getCommonHeader() != null);
 388 //        Assert.assertEquals("should return success status",
 389 //                new Integer(302), outputBuilder.getStatus().getCode());
 390 //    }
 391 //}
 392
 393 //    @Test
 394 //    public void testValidateForPreCheckAction() throws Exception {
 395 //        // test commonHeader error
 396 //        upgradePreAction.validate(mockCommonHeader, Action.UpgradePreCheck, mockAI, mockPayload);
 397 //        Status status = (Status) Whitebox.getInternalState(upgradePreAction, "status");
 398 //        Assert.assertEquals("should return missing parameter",
 399 //            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
 400 //        //Mockito.verify(upgradePreAction, times(0)).buildStatusForParamName(any(), any());
 401 //       // Mockito.verify(upgradePreAction, times(0)).buildStatusForErrorMsg(any(), any());
 402 //
 403 //        ZULU mockTimeStamp = mock(ZULU.class);
 404 //        Mockito.doReturn(mockTimeStamp).when(mockCommonHeader).getTimestamp();
 405 //        Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
 406 //        Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
 407 //        Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
 408 //
 409 //        // test Invalid action
 410 //        upgradePreAction.validate(mockCommonHeader, Action.UpgradePreCheck, mockAI, mockPayload);
 411 //        status = (Status) Whitebox.getInternalState(upgradePreAction, "status");
 412 //        Assert.assertEquals("Should return invalid parameter for action",
 413 //            Integer.valueOf(302), status.getCode());
 414 //
 415 //        // test empty ActionIdentifier
 416 //        upgradePreAction.validate(mockCommonHeader, Action.UpgradePreCheck, mockAI, mockPayload);
 417 //        status = (Status) Whitebox.getInternalState(upgradePreAction, "status");
 418 //        Assert.assertEquals("should return missing parameter",
 419 //            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
 420 //
 421 //        // test empty VSERVER_ID
 422 //        Mockito.doReturn("").when(mockAI).getVnfId();
 423 //        upgradePreAction.validate(mockCommonHeader, Action.UpgradePreCheck, mockAI, mockPayload);
 424 //        status = (Status) Whitebox.getInternalState(upgradePreAction, "status");
 425 //        Assert.assertEquals("should return invalid parameter",
 426 //            Integer.valueOf(302), status.getCode());
 427 //
 428 //        Mockito.doReturn("vnfId").when(mockAI).getVnfId();
 429 //
 430 //        // test null payload
 431 //        upgradePreAction.validate(mockCommonHeader, Action.UpgradePreCheck, mockAI, null);
 432 //        //Mockito.verify(upgradePreAction, times(1)).validateExcludedActIds(any(), any());
 433 //        status = (Status) Whitebox.getInternalState(upgradePreAction, "status");
 434 //        Assert.assertEquals("should return missing parameter",
 435 //            Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
 436 //
 437 //        // test empty payload
 438 //        Mockito.doReturn("").when(mockPayload).getValue();
 439 //        upgradePreAction.validate(mockCommonHeader, Action.UpgradePreCheck, mockAI, mockPayload);
 440 //        status = (Status) Whitebox.getInternalState(upgradePreAction, "status");
 441 //        Assert.assertEquals("should return invalid parameter",
 442 //            Integer.valueOf(302), status.getCode());
 443 //
 444 //        // test space payload
 445 //        Mockito.doReturn(" ").when(mockPayload).getValue();
 446 //        upgradePreAction.validate(mockCommonHeader, Action.UpgradePreCheck, mockAI, mockPayload);
 447 //        status = (Status) Whitebox.getInternalState(upgradePreAction, "status");
 448 //        Assert.assertEquals("should return invalid parameter",
 449 //            Integer.valueOf(302), status.getCode());
 450 //    }
 451 //
 452 //    @Test
 453 //    public void testValidateForUpgradePostAction() throws Exception {
 454 //        // test commonHeader error
 455 //        upgradePostAction.validate(mockCommonHeader, Action.UpgradePostCheck, mockAI, mockPayload);
 456 //        Status status = (Status) Whitebox.getInternalState(upgradePostAction, "status");
 457 //        Assert.assertEquals("should return missing parameter",
 458 //                Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
 459 //       // Mockito.verify(upgradePostAction, times(0)).buildStatusForParamName(any(), any());
 460 //        //Mockito.verify(upgradePostAction, times(0)).buildStatusForErrorMsg(any(), any());
 461 //
 462 //        ZULU mockTimeStamp = mock(ZULU.class);
 463 //        Mockito.doReturn(mockTimeStamp).when(mockCommonHeader).getTimestamp();
 464 //        Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
 465 //        Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
 466 //        Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
 467 //
 468 //        // test Invalid action
 469 //        upgradePostAction.validate(mockCommonHeader, Action.UpgradePostCheck, mockAI, mockPayload);
 470 //        status = (Status) Whitebox.getInternalState(upgradePostAction, "status");
 471 //        Assert.assertEquals("Should return invalid parameter for action",
 472 //                Integer.valueOf(302), status.getCode());
 473 //
 474 //        // test empty ActionIdentifier
 475 //        upgradePostAction.validate(mockCommonHeader, Action.UpgradePostCheck, mockAI, mockPayload);
 476 //        status = (Status) Whitebox.getInternalState(upgradePostAction, "status");
 477 //        Assert.assertEquals("should return missing parameter",
 478 //                Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
 479 //
 480 //        // test empty VSERVER_ID
 481 //        Mockito.doReturn("").when(mockAI).getVnfId();
 482 //        upgradePostAction.validate(mockCommonHeader, Action.UpgradePostCheck, mockAI, mockPayload);
 483 //        status = (Status) Whitebox.getInternalState(upgradePostAction, "status");
 484 //        Assert.assertEquals("should return invalid parameter",
 485 //                Integer.valueOf(302), status.getCode());
 486 //
 487 //        Mockito.doReturn("vnfId").when(mockAI).getVnfId();
 488 //
 489 //        // test null payload
 490 //        upgradePostAction.validate(mockCommonHeader, Action.UpgradePostCheck, mockAI, null);
 491 //        //Mockito.verify(upgradePostAction, times(1)).validateExcludedActIds(any(), any());
 492 //        status = (Status) Whitebox.getInternalState(upgradePostAction, "status");
 493 //        Assert.assertEquals("should return missing parameter",
 494 //                Integer.valueOf(302), status.getCode());
 495 //
 496 //        // test empty payload
 497 //        Mockito.doReturn("").when(mockPayload).getValue();
 498 //        upgradePostAction.validate(mockCommonHeader, Action.UpgradePostCheck, mockAI, mockPayload);
 499 //        status = (Status) Whitebox.getInternalState(upgradePostAction, "status");
 500 //        Assert.assertEquals("should return invalid parameter",
 501 //                Integer.valueOf(302), status.getCode());
 502 //
 503 //        // test space payload
 504 //        Mockito.doReturn(" ").when(mockPayload).getValue();
 505 //        upgradePostAction.validate(mockCommonHeader, Action.UpgradePostCheck, mockAI, mockPayload);
 506 //        status = (Status) Whitebox.getInternalState(upgradePostAction, "status");
 507 //        Assert.assertEquals("should return invalid parameter",
 508 //                Integer.valueOf(302), status.getCode());
 509 //    }
 510 //    @Test
 511 //    public void testValidateForUpgradeBackoutAction() throws Exception {
 512 //        // test commonHeader error
 513 //        upgradeBackoutAction.validate(mockCommonHeader, Action.UpgradeBackout, mockAI, mockPayload);
 514 //        Status status = (Status) Whitebox.getInternalState(upgradeBackoutAction, "status");
 515 //        Assert.assertEquals("should return missing parameter",
 516 //                Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
 517 //        //Mockito.verify(upgradeBackoutAction, times(0)).buildStatusForParamName(any(), any());
 518 //       // Mockito.verify(upgradeBackoutAction, times(0)).buildStatusForErrorMsg(any(), any());
 519 //
 520 //        ZULU mockTimeStamp = mock(ZULU.class);
 521 //        Mockito.doReturn(mockTimeStamp).when(mockCommonHeader).getTimestamp();
 522 //        Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
 523 //        Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
 524 //        Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
 525 //
 526 //        // test Invalid action
 527 //        upgradeBackoutAction.validate(mockCommonHeader, Action.UpgradeBackout, mockAI, mockPayload);
 528 //        status = (Status) Whitebox.getInternalState(upgradeBackoutAction, "status");
 529 //        Assert.assertEquals("Should return invalid parameter for action",
 530 //                Integer.valueOf(302), status.getCode());
 531 //
 532 //        // test empty ActionIdentifier
 533 //        upgradeBackoutAction.validate(mockCommonHeader, Action.UpgradeBackout, mockAI, mockPayload);
 534 //        status = (Status) Whitebox.getInternalState(upgradeBackoutAction, "status");
 535 //        Assert.assertEquals("should return missing parameter",
 536 //                Integer.valueOf(302), status.getCode());
 537 //
 538 //        // test empty VSERVER_ID
 539 //        Mockito.doReturn("").when(mockAI).getVnfId();
 540 //        upgradeBackoutAction.validate(mockCommonHeader, Action.UpgradeBackout, mockAI, mockPayload);
 541 //        status = (Status) Whitebox.getInternalState(upgradeBackoutAction, "status");
 542 //        Assert.assertEquals("should return invalid parameter",
 543 //                Integer.valueOf(302), status.getCode());
 544 //
 545 //        Mockito.doReturn("vnfId").when(mockAI).getVnfId();
 546 //
 547 //        // test null payload
 548 //        upgradeBackoutAction.validate(mockCommonHeader, Action.UpgradeBackout, mockAI, null);
 549 //       // Mockito.verify(upgradeBackoutAction, times(1)).validateExcludedActIds(any(), any());
 550 //        status = (Status) Whitebox.getInternalState(upgradeBackoutAction, "status");
 551 //        Assert.assertEquals("should return missing parameter",
 552 //                Integer.valueOf(302), status.getCode());
 553 //
 554 //        // test empty payload
 555 //        Mockito.doReturn("").when(mockPayload).getValue();
 556 //        upgradeBackoutAction.validate(mockCommonHeader, Action.UpgradeBackout, mockAI, mockPayload);
 557 //        status = (Status) Whitebox.getInternalState(upgradeBackoutAction, "status");
 558 //        Assert.assertEquals("should return invalid parameter",
 559 //                Integer.valueOf(302), status.getCode());
 560 //
 561 //        // test space payload
 562 //        Mockito.doReturn(" ").when(mockPayload).getValue();
 563 //        upgradeBackoutAction.validate(mockCommonHeader, Action.UpgradeBackout, mockAI, mockPayload);
 564 //        status = (Status) Whitebox.getInternalState(upgradeBackoutAction, "status");
 565 //        Assert.assertEquals("should return invalid parameter",
 566 //                Integer.valueOf(302), status.getCode());
 567 //    }
 568 //
 569 //    @Test
 570 //    public void testValidateForUpgradeSoftwareAction() throws Exception {
 571 //        // test commonHeader error
 572 //        upgradeSoftAction.validate(mockCommonHeader, Action.UpgradeSoftware, mockAI, mockPayload);
 573 //        Status status = (Status) Whitebox.getInternalState(upgradeSoftAction, "status");
 574 //        Assert.assertEquals("should return missing parameter",
 575 //                Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
 576 //        //Mockito.verify(upgradeSoftAction, times(0)).buildStatusForParamName(any(), any());
 577 //        //Mockito.verify(upgradeSoftAction, times(0)).buildStatusForErrorMsg(any(), any());
 578 //
 579 //        ZULU mockTimeStamp = mock(ZULU.class);
 580 //        Mockito.doReturn(mockTimeStamp).when(mockCommonHeader).getTimestamp();
 581 //        Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
 582 //        Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
 583 //        Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
 584 //
 585 //        // test Invalid action
 586 //        upgradeSoftAction.validate(mockCommonHeader, Action.UpgradeSoftware, mockAI, mockPayload);
 587 //        status = (Status) Whitebox.getInternalState(upgradeSoftAction, "status");
 588 //        Assert.assertEquals("Should return invalid parameter for action",
 589 //                Integer.valueOf(302), status.getCode());
 590 //
 591 //        // test empty ActionIdentifier
 592 //        upgradeSoftAction.validate(mockCommonHeader, Action.UpgradeSoftware, mockAI, mockPayload);
 593 //        status = (Status) Whitebox.getInternalState(upgradeSoftAction, "status");
 594 //        Assert.assertEquals("should return missing parameter",
 595 //                Integer.valueOf(302), status.getCode());
 596 //
 597 //        // test empty VSERVER_ID
 598 //        Mockito.doReturn("").when(mockAI).getVnfId();
 599 //        upgradeSoftAction.validate(mockCommonHeader, Action.UpgradeSoftware, mockAI, mockPayload);
 600 //        status = (Status) Whitebox.getInternalState(upgradeSoftAction, "status");
 601 //        Assert.assertEquals("should return invalid parameter",
 602 //                Integer.valueOf(302), status.getCode());
 603 //
 604 //        Mockito.doReturn("vnfId").when(mockAI).getVnfId();
 605 //
 606 //        // test null payload
 607 //        upgradeSoftAction.validate(mockCommonHeader, Action.UpgradeSoftware, mockAI, null);
 608 //        //Mockito.verify(upgradeSoftAction, times(1)).validateExcludedActIds(any(), any());
 609 //        status = (Status) Whitebox.getInternalState(upgradeSoftAction, "status");
 610 //        Assert.assertEquals("should return missing parameter",
 611 //                Integer.valueOf(302), status.getCode());
 612 //
 613 //        // test empty payload
 614 //        Mockito.doReturn("").when(mockPayload).getValue();
 615 //        upgradeSoftAction.validate(mockCommonHeader, Action.UpgradeSoftware, mockAI, mockPayload);
 616 //        status = (Status) Whitebox.getInternalState(upgradeSoftAction, "status");
 617 //        Assert.assertEquals("should return invalid parameter",
 618 //                Integer.valueOf(302), status.getCode());
 619 //
 620 //        // test space payload
 621 //        Mockito.doReturn(" ").when(mockPayload).getValue();
 622 //        upgradeSoftAction.validate(mockCommonHeader, Action.UpgradeSoftware, mockAI, mockPayload);
 623 //        status = (Status) Whitebox.getInternalState(upgradeSoftAction, "status");
 624 //        Assert.assertEquals("should return invalid parameter",
 625 //                Integer.valueOf(302), status.getCode());
 626 //    }
 627 //
 628 //    @Test
 629 //    public void testValidateForUpgradeBackupAction() throws Exception {
 630 //        // test commonHeader error
 631 //        upgradeBackupAction.validate(mockCommonHeader, Action.UpgradeBackup, mockAI, mockPayload);
 632 //        Status status = (Status) Whitebox.getInternalState(upgradeBackupAction, "status");
 633 //        Assert.assertEquals("should return missing parameter",
 634 //                Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()), status.getCode());
 635 //        //Mockito.verify(upgradeBackupAction, times(0)).buildStatusForParamName(any(), any());
 636 //        //Mockito.verify(upgradeBackupAction, times(0)).buildStatusForErrorMsg(any(), any());
 637 //
 638 //        ZULU mockTimeStamp = mock(ZULU.class);
 639 //        Mockito.doReturn(mockTimeStamp).when(mockCommonHeader).getTimestamp();
 640 //        Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
 641 //        Mockito.doReturn("orignator Id").when(mockCommonHeader).getOriginatorId();
 642 //        Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
 643 //
 644 //        // test Invalid action
 645 //        upgradeBackupAction.validate(mockCommonHeader, Action.UpgradeBackup, mockAI, mockPayload);
 646 //        status = (Status) Whitebox.getInternalState(upgradeBackupAction, "status");
 647 //        Assert.assertEquals("Should return invalid parameter for action",
 648 //                Integer.valueOf(302), status.getCode());
 649 //
 650 //        // test empty ActionIdentifier
 651 //        upgradeBackupAction.validate(mockCommonHeader, Action.UpgradeBackup, mockAI, mockPayload);
 652 //        status = (Status) Whitebox.getInternalState(upgradeBackupAction, "status");
 653 //        Assert.assertEquals("should return missing parameter",
 654 //                Integer.valueOf(302), status.getCode());
 655 //
 656 //        // test empty VSERVER_ID
 657 //        Mockito.doReturn("").when(mockAI).getVnfId();
 658 //        upgradeBackupAction.validate(mockCommonHeader, Action.UpgradeBackup, mockAI, mockPayload);
 659 //        status = (Status) Whitebox.getInternalState(upgradeBackupAction, "status");
 660 //        Assert.assertEquals("should return invalid parameter",
 661 //                Integer.valueOf(302), status.getCode());
 662 //
 663 //        Mockito.doReturn("vnfId").when(mockAI).getVnfId();
 664 //
 665 //        // test null payload
 666 //        upgradeBackupAction.validate(mockCommonHeader, Action.UpgradeBackup, mockAI, null);
 667 //        //Mockito.verify(upgradeBackupAction, times(1)).validateExcludedActIds(any(), any());
 668 //        status = (Status) Whitebox.getInternalState(upgradeBackupAction, "status");
 669 //        Assert.assertEquals("should return missing parameter",
 670 //                Integer.valueOf(302), status.getCode());
 671 //
 672 //        // test empty payload
 673 //        Mockito.doReturn("").when(mockPayload).getValue();
 674 //        upgradeBackupAction.validate(mockCommonHeader, Action.UpgradeBackup, mockAI, mockPayload);
 675 //        status = (Status) Whitebox.getInternalState(upgradeBackupAction, "status");
 676 //        Assert.assertEquals("should return invalid parameter",
 677 //                Integer.valueOf(302), status.getCode());
 678 //
 679 //        // test space payload
 680 //        Mockito.doReturn(" ").when(mockPayload).getValue();
 681 //        upgradeBackupAction.validate(mockCommonHeader, Action.UpgradeBackup, mockAI, mockPayload);
 682 //        status = (Status) Whitebox.getInternalState(upgradeBackupAction, "status");
 683 //        Assert.assertEquals("should return invalid parameter",
 684 //                Integer.valueOf(302), status.getCode());
 685 //    }
 686 }