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

   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.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.Action;
  32 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ActionStatusInput;
  33 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ActionStatusOutputBuilder;
  34 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.Payload;
  35 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.ZULU;
  36 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.action.identifiers.ActionIdentifiers;
  37 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.common.header.CommonHeader;
  38 import org.onap.appc.domainmodel.lcm.ActionLevel;
  39 import org.onap.appc.domainmodel.lcm.RequestContext;
  40 import org.onap.appc.domainmodel.lcm.ResponseContext;
  41 import org.onap.appc.domainmodel.lcm.Status;
  42 import org.onap.appc.executor.objects.LCMCommandStatus;
  43 import org.onap.appc.provider.lcm.util.RequestInputBuilder;
  44 import org.onap.appc.requesthandler.objects.RequestHandlerInput;
  45 import org.onap.appc.requesthandler.objects.RequestHandlerOutput;
  46 import org.powermock.core.classloader.annotations.PrepareForTest;
  47 import org.powermock.modules.junit4.PowerMockRunner;
  48 import org.powermock.reflect.Whitebox;
  49
  50 import java.text.ParseException;
  51
  52 import static org.mockito.Matchers.any;
  53 import static org.mockito.Mockito.mock;
  54 import static org.mockito.Mockito.spy;
  55 import static org.mockito.Mockito.times;
  56 import static org.powermock.api.mockito.PowerMockito.whenNew;
  57
  58
  59 @RunWith(PowerMockRunner.class)
  60 @PrepareForTest({ActionStatusService.class, RequestExecutor.class, RequestInputBuilder.class,})
  61 public class ActionStatusServiceTest {
  62     private RequestHandlerInput mockRequestHandlerInput = mock(RequestHandlerInput.class);
  63     private RequestContext mockRequestContext = mock(RequestContext.class);
  64     private RequestHandlerOutput mockOutput = mock(RequestHandlerOutput.class);
  65     private ResponseContext mockResponseContext = mock(ResponseContext.class);
  66
  67     private ActionStatusService actionStatusService;
  68
  69     @Before
  70     public void setUp() throws Exception {
  71         Mockito.doReturn(mockRequestContext).when(mockRequestHandlerInput).getRequestContext();
  72         actionStatusService = spy(new ActionStatusService());
  73     }
  74
  75     @Test
  76     public void testConstructor() throws Exception {
  77         Assert.assertEquals("Should have proper ACTION", Action.ActionStatus,
  78             (Action) Whitebox.getInternalState(actionStatusService, "expectedAction"));
  79         Assert.assertEquals("Should have action-status RPC name", "action-status",
  80             (Whitebox.getInternalState(actionStatusService, "rpcName")).toString());
  81     }
  82
  83     @Test
  84     public void testQueryStatus() throws Exception {
  85         // ===========   test input validation ============
  86         CommonHeader mockCommonHeader = mock(CommonHeader.class);
  87         ActionStatusInput mockInput = mock(ActionStatusInput.class);
  88
  89         Mockito.doReturn(mockCommonHeader).when(mockInput).getCommonHeader();
  90         // test commonHeader error
  91         ActionStatusOutputBuilder output = actionStatusService.queryStatus(mockInput);
  92         Assert.assertEquals("Should have commonHeader", mockCommonHeader, output.getCommonHeader());
  93         Assert.assertEquals("should return missing parameter",
  94             Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()),
  95             output.getStatus().getCode());
  96
  97         ZULU zuluTimeStamp = new ZULU("2017-06-29T21:44:00.35Z");
  98         Mockito.doReturn(zuluTimeStamp).when(mockCommonHeader).getTimestamp();
  99         Mockito.doReturn("api ver").when(mockCommonHeader).getApiVer();
 100         Mockito.doReturn("originator Id").when(mockCommonHeader).getOriginatorId();
 101         Mockito.doReturn("request Id").when(mockCommonHeader).getRequestId();
 102
 103         // test invalid action
 104         Mockito.doReturn(Action.Query).when(mockInput).getAction();
 105         output = actionStatusService.queryStatus(mockInput);
 106         Assert.assertEquals("Should have commonHeader", mockCommonHeader, output.getCommonHeader());
 107         Assert.assertEquals("Should return invalid parameter for action",
 108             Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()),
 109             output.getStatus().getCode());
 110
 111         // test null actionIdentifier
 112         Mockito.doReturn(Action.ActionStatus).when(mockInput).getAction();
 113         output = actionStatusService.queryStatus(mockInput);
 114         Assert.assertEquals("Should have commonHeader", mockCommonHeader, output.getCommonHeader());
 115         Assert.assertEquals("should return missing parameter",
 116             Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()),
 117             output.getStatus().getCode());
 118
 119         // test missing VNF ID
 120         ActionIdentifiers mockAI = mock(ActionIdentifiers.class);
 121         Mockito.doReturn(mockAI).when(mockInput).getActionIdentifiers();
 122         output = actionStatusService.queryStatus(mockInput);
 123         Assert.assertEquals("Should have commonHeader", mockCommonHeader, output.getCommonHeader());
 124         Assert.assertEquals("should return missing parameter",
 125             Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()),
 126             output.getStatus().getCode());
 127
 128         // test invalid VNF ID
 129         Mockito.doReturn("").when(mockAI).getVnfId();
 130         output = actionStatusService.queryStatus(mockInput);
 131         Assert.assertEquals("Should have commonHeader", mockCommonHeader, output.getCommonHeader());
 132         Assert.assertEquals("Should return invalid parameter for action",
 133             Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()),
 134             output.getStatus().getCode());
 135
 136         // test null payload
 137         Mockito.doReturn("test VNF ID").when(mockAI).getVnfId();
 138         output = actionStatusService.queryStatus(mockInput);
 139         Assert.assertEquals("Should have commonHeader", mockCommonHeader, output.getCommonHeader());
 140         Assert.assertEquals("should return missing parameter",
 141             Integer.valueOf(LCMCommandStatus.MISSING_MANDATORY_PARAMETER.getResponseCode()),
 142             output.getStatus().getCode());
 143
 144         // test payload with empty string
 145         Payload mockPayload = mock(Payload.class);
 146         Mockito.doReturn(mockPayload).when(mockInput).getPayload();
 147         output = actionStatusService.queryStatus(mockInput);
 148         Assert.assertEquals("Should have commonHeader", mockCommonHeader, output.getCommonHeader());
 149         Assert.assertEquals("should return invalid parameter",
 150             Integer.valueOf(LCMCommandStatus.INVALID_INPUT_PARAMETER.getResponseCode()),
 151             output.getStatus().getCode());
 152
 153         // test validation passed
 154         Mockito.doReturn("testing payload").when(mockPayload).getValue();
 155
 156         // ===========   test success ============
 157         RequestExecutor mockExecutor = mock(RequestExecutor.class);
 158         whenNew(RequestExecutor.class).withNoArguments().thenReturn(mockExecutor);
 159         Mockito.doReturn(mockOutput).when(mockExecutor).executeRequest(any());
 160         Mockito.doReturn(mockPayload).when(mockExecutor).getPayload(mockOutput);
 161
 162         Mockito.doReturn(mockResponseContext).when(mockOutput).getResponseContext();
 163
 164         Integer statusCode = 400;
 165         Status mockStatus = mock(Status.class);
 166         Mockito.doReturn(statusCode).when(mockStatus).getCode();
 167         Mockito.doReturn(mockStatus).when(mockResponseContext).getStatus();
 168
 169         output = actionStatusService.queryStatus(mockInput);
 170         Mockito.verify(actionStatusService, times(1)).buildStatusWithDispatcherOutput(mockOutput);
 171         Mockito.verify(mockExecutor, times(1)).getPayload(mockOutput);
 172         Assert.assertTrue("Should have payload", output.getPayload() != null);
 173         Assert.assertEquals("Should have commonHeader", mockCommonHeader, output.getCommonHeader());
 174         Assert.assertEquals("Should return proper code", statusCode, output.getStatus().getCode());
 175
 176         // ===========   test parserException ============
 177         RequestInputBuilder mockInputBuilder = mock(RequestInputBuilder.class);
 178         whenNew(RequestInputBuilder.class).withNoArguments().thenReturn(mockInputBuilder);
 179         Mockito.doReturn(mockInputBuilder).when(mockInputBuilder).requestContext();
 180         ParseException parserException = new ParseException("testing exception", 0);
 181         Mockito.doThrow(parserException).when(mockInputBuilder).commonHeader(mockCommonHeader);
 182
 183         output = actionStatusService.queryStatus(mockInput);
 184         Mockito.verify(actionStatusService, times(1)).buildStatusWithParseException(parserException);
 185         Assert.assertEquals("Should have commonHeader", mockCommonHeader, output.getCommonHeader());
 186         Assert.assertEquals("Should return request failed",
 187             Integer.valueOf(LCMCommandStatus.REQUEST_PARSING_FAILED.getResponseCode()),
 188             output.getStatus().getCode());
 189     }
 190
 191     @Test
 192     public void testUpdateToMgmtActionLevel() throws Exception {
 193         actionStatusService.updateToMgmtActionLevel(mockRequestHandlerInput);
 194         Mockito.verify(mockRequestContext, times(1)).setActionLevel(ActionLevel.MGMT);
 195     }
 196 }