models-interactions/model-actors/actor.appclcm/src/test/java/org/onap/policy/controlloop/actor/appclcm/AppcLcmOperationTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * AppcLcmOperation
   4  * ================================================================================
   5  * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.policy.controlloop.actor.appclcm;
  22
  23 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
  24 import static org.junit.Assert.assertEquals;
  25 import static org.junit.Assert.assertNotNull;
  26 import static org.junit.Assert.assertNull;
  27 import static org.mockito.ArgumentMatchers.any;
  28 import static org.mockito.Mockito.atLeast;
  29
  30 import java.util.List;
  31 import java.util.UUID;
  32 import org.junit.Before;
  33 import org.junit.Ignore;
  34 import org.junit.Test;
  35 import org.mockito.Mockito;
  36 import org.onap.policy.appclcm.AppcLcmBody;
  37 import org.onap.policy.appclcm.AppcLcmCommonHeader;
  38 import org.onap.policy.appclcm.AppcLcmDmaapWrapper;
  39 import org.onap.policy.appclcm.AppcLcmInput;
  40 import org.onap.policy.appclcm.AppcLcmOutput;
  41 import org.onap.policy.appclcm.AppcLcmResponseStatus;
  42 import org.onap.policy.controlloop.VirtualControlLoopEvent;
  43 import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
  44 import org.onap.policy.controlloop.actorserviceprovider.controlloop.ControlLoopEventContext;
  45 import org.onap.policy.controlloop.actorserviceprovider.impl.BidirectionalTopicOperation.Status;
  46 import org.onap.policy.controlloop.actorserviceprovider.parameters.ControlLoopOperationParams;
  47 import org.onap.policy.controlloop.policy.PolicyResult;
  48 import org.powermock.reflect.Whitebox;
  49
  50 public class AppcLcmOperationTest {
  51     private AppcLcmInput mockInput;
  52     private AppcLcmOutput mockOutput;
  53     private AppcLcmBody mockBody;
  54     private AppcLcmDmaapWrapper mockInputWrapper;
  55     private AppcLcmDmaapWrapper mockOutputWrapper;
  56     private OperationOutcome mockOperationOutcome;
  57     private AppcLcmOperation operation;
  58     private AppcLcmResponseStatus mockResponseStatus;
  59     private AppcLcmCommonHeader mockCommonHeader;
  60     private ControlLoopOperationParams mockParams;
  61     private ControlLoopEventContext mockContext;
  62     private VirtualControlLoopEvent mockEvent;
  63
  64     /**
  65      * Setup mocks for testing.
  66      */
  67     @Before
  68     public void setup() {
  69         mockInput = Mockito.mock(AppcLcmInput.class);
  70         mockOutput = Mockito.mock(AppcLcmOutput.class);
  71         mockBody = Mockito.mock(AppcLcmBody.class);
  72         mockContext = Mockito.mock(ControlLoopEventContext.class);
  73         mockEvent = Mockito.mock(VirtualControlLoopEvent.class);
  74         mockInputWrapper = Mockito.mock(AppcLcmDmaapWrapper.class);
  75         mockOutputWrapper = Mockito.mock(AppcLcmDmaapWrapper.class);
  76         mockOperationOutcome = Mockito.mock(OperationOutcome.class);
  77         mockResponseStatus = Mockito.mock(AppcLcmResponseStatus.class);
  78         mockCommonHeader = Mockito.mock(AppcLcmCommonHeader.class);
  79         mockParams = Mockito.mock(ControlLoopOperationParams.class);
  80         operation = Mockito.mock(AppcLcmOperation.class);
  81     }
  82
  83     @Test
  84     public void testStartPreprocessorAsync() {
  85         Mockito.doCallRealMethod().when(operation).startPreprocessorAsync();
  86         assertNull(operation.startPreprocessorAsync());
  87     }
  88
  89     @Ignore
  90     @Test
  91     public void testMakeRequest() {
  92         UUID randomId = UUID.randomUUID();
  93         Mockito.doCallRealMethod().when(operation).makeRequest(1, "sampleTargetVnf");
  94         Mockito.when(mockParams.getRequestId()).thenReturn(randomId);
  95         Mockito.when(mockParams.getPayload()).thenReturn(null);
  96         Mockito.when(mockParams.getContext()).thenReturn(mockContext);
  97         Mockito.when(mockParams.getOperation()).thenReturn("Config-Modify");
  98         Mockito.when(mockContext.getEvent()).thenReturn(mockEvent);
  99         Mockito.when(mockEvent.getRequestId()).thenReturn(randomId);
 100         Whitebox.setInternalState(operation, "params", mockParams);
 101         assertNotNull(operation.makeRequest(1, "sampleTargetVnf"));
 102         Mockito.verify(mockParams, atLeast(1)).getRequestId();
 103         Mockito.verify(mockParams, atLeast(1)).getPayload();
 104         Mockito.verify(mockParams, atLeast(1)).getContext();
 105         Mockito.verify(mockContext, atLeast(1)).getEvent();
 106         Mockito.verify(mockEvent, atLeast(1)).getRequestId();
 107     }
 108
 109     @Test
 110     public void testGetExpectedKeyValues() {
 111         Mockito.doCallRealMethod().when(operation).getExpectedKeyValues(1, mockInputWrapper);
 112         Mockito.when(mockInputWrapper.getBody()).thenReturn(mockBody);
 113         Mockito.when(mockBody.getInput()).thenReturn(mockInput);
 114         Mockito.when(mockInput.getCommonHeader()).thenReturn(mockCommonHeader);
 115         Mockito.when(mockCommonHeader.getSubRequestId()).thenReturn("sampleSubRequestId");
 116
 117         List<String> retList = operation.getExpectedKeyValues(1, mockInputWrapper);
 118         assertNotNull(retList);
 119         assertEquals(1, retList.size());
 120
 121         Mockito.verify(mockInputWrapper, atLeast(1)).getBody();
 122         Mockito.verify(mockBody, atLeast(1)).getInput();
 123         Mockito.verify(mockInput, atLeast(1)).getCommonHeader();
 124         Mockito.verify(mockCommonHeader, atLeast(1)).getSubRequestId();
 125     }
 126
 127     @Test
 128     public void testDetmStatus() {
 129         Mockito.doCallRealMethod().when(operation).detmStatus("testResponse", mockOutputWrapper);
 130         Mockito.when(mockOutputWrapper.getBody()).thenReturn(mockBody);
 131         Mockito.when(mockBody.getOutput()).thenReturn(mockOutput);
 132         Mockito.when(mockOutput.getStatus()).thenReturn(mockResponseStatus);
 133         Mockito.when(mockResponseStatus.getCode()).thenReturn(100);
 134         Status retStatus = operation.detmStatus("testResponse", mockOutputWrapper);
 135         assertEquals(Status.STILL_WAITING, retStatus);
 136
 137         Mockito.when(mockResponseStatus.getCode()).thenReturn(400);
 138         retStatus = operation.detmStatus("testResponse", mockOutputWrapper);
 139         assertEquals(Status.SUCCESS, retStatus);
 140
 141         Mockito.when(mockResponseStatus.getCode()).thenReturn(450);
 142         retStatus = operation.detmStatus("testResponse", mockOutputWrapper);
 143         assertEquals(Status.FAILURE, retStatus);
 144
 145         Mockito.when(mockOutput.getStatus()).thenReturn(null);
 146         assertThatIllegalArgumentException().isThrownBy(() -> operation.detmStatus("testResponse", mockOutputWrapper));
 147
 148         Mockito.when(mockResponseStatus.getCode()).thenReturn(200);
 149         assertThatIllegalArgumentException().isThrownBy(() -> operation.detmStatus("testResponse", mockOutputWrapper));
 150
 151         Mockito.verify(mockOutputWrapper, atLeast(1)).getBody();
 152         Mockito.verify(mockBody, atLeast(1)).getOutput();
 153         Mockito.verify(mockOutput, atLeast(1)).getStatus();
 154         Mockito.verify(mockResponseStatus, atLeast(1)).getCode();
 155     }
 156
 157     @Test
 158     public void testSetOutcome() {
 159         Mockito.doCallRealMethod().when(operation).setOutcome(mockOperationOutcome, PolicyResult.SUCCESS,
 160                 mockOutputWrapper);
 161         Mockito.doCallRealMethod().when(operation).setOutcome(mockOperationOutcome, PolicyResult.FAILURE,
 162                 mockOutputWrapper);
 163
 164         Mockito.doCallRealMethod().when(mockOperationOutcome).setResult(any(PolicyResult.class));
 165         Mockito.doCallRealMethod().when(mockOperationOutcome).setMessage(any(String.class));
 166         Mockito.doCallRealMethod().when(mockOperationOutcome).getResult();
 167         Mockito.doCallRealMethod().when(mockOperationOutcome).getMessage();
 168
 169         Mockito.when(mockOutputWrapper.getBody()).thenReturn(mockBody);
 170         Mockito.when(mockBody.getOutput()).thenReturn(mockOutput);
 171         Mockito.when(mockOutput.getStatus()).thenReturn(mockResponseStatus);
 172         Mockito.when(mockResponseStatus.getMessage()).thenReturn(null);
 173
 174         OperationOutcome result = operation.setOutcome(mockOperationOutcome, PolicyResult.SUCCESS, mockOutputWrapper);
 175         assertNull(result);
 176         Mockito.verify(operation).setOutcome(mockOperationOutcome, PolicyResult.SUCCESS, mockOutputWrapper);
 177
 178         Mockito.when(mockOutput.getStatus()).thenReturn(mockResponseStatus);
 179         Mockito.when(mockResponseStatus.getMessage()).thenReturn("sampleMessage");
 180         result = operation.setOutcome(mockOperationOutcome, PolicyResult.FAILURE, mockOutputWrapper);
 181         assertEquals(PolicyResult.FAILURE, result.getResult());
 182         assertNotNull(result.getMessage());
 183
 184         Mockito.verify(mockOutputWrapper, atLeast(1)).getBody();
 185         Mockito.verify(mockBody, atLeast(1)).getOutput();
 186         Mockito.verify(mockOutput, atLeast(1)).getStatus();
 187         Mockito.verify(mockResponseStatus, atLeast(1)).getMessage();
 188         Mockito.verify(operation, atLeast(1)).setOutcome(mockOperationOutcome, PolicyResult.SUCCESS, mockOutputWrapper);
 189         Mockito.verify(operation, atLeast(1)).setOutcome(mockOperationOutcome, PolicyResult.FAILURE, mockOutputWrapper);
 190     }
 191
 192 }