gerrit.onap Code Review - appc.git/blob

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