--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * AppcLcmOperation
+ * ================================================================================
+ * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.controlloop.actor.appclcm;
+
+import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.atLeast;
+
+import java.util.List;
+import java.util.UUID;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.onap.policy.appclcm.AppcLcmBody;
+import org.onap.policy.appclcm.AppcLcmCommonHeader;
+import org.onap.policy.appclcm.AppcLcmDmaapWrapper;
+import org.onap.policy.appclcm.AppcLcmInput;
+import org.onap.policy.appclcm.AppcLcmOutput;
+import org.onap.policy.appclcm.AppcLcmResponseStatus;
+import org.onap.policy.controlloop.VirtualControlLoopEvent;
+import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
+import org.onap.policy.controlloop.actorserviceprovider.controlloop.ControlLoopEventContext;
+import org.onap.policy.controlloop.actorserviceprovider.impl.BidirectionalTopicOperation.Status;
+import org.onap.policy.controlloop.actorserviceprovider.parameters.ControlLoopOperationParams;
+import org.onap.policy.controlloop.policy.PolicyResult;
+import org.powermock.reflect.Whitebox;
+
+public class AppcLcmOperationTest {
+ private AppcLcmInput mockInput;
+ private AppcLcmOutput mockOutput;
+ private AppcLcmBody mockBody;
+ private AppcLcmDmaapWrapper mockInputWrapper;
+ private AppcLcmDmaapWrapper mockOutputWrapper;
+ private OperationOutcome mockOperationOutcome;
+ private AppcLcmOperation operation;
+ private AppcLcmResponseStatus mockResponseStatus;
+ private AppcLcmCommonHeader mockCommonHeader;
+ private ControlLoopOperationParams mockParams;
+ private ControlLoopEventContext mockContext;
+ private VirtualControlLoopEvent mockEvent;
+
+ /**
+ * Setup mocks for testing.
+ */
+ @Before
+ public void setup() {
+ mockInput = Mockito.mock(AppcLcmInput.class);
+ mockOutput = Mockito.mock(AppcLcmOutput.class);
+ mockBody = Mockito.mock(AppcLcmBody.class);
+ mockContext = Mockito.mock(ControlLoopEventContext.class);
+ mockEvent = Mockito.mock(VirtualControlLoopEvent.class);
+ mockInputWrapper = Mockito.mock(AppcLcmDmaapWrapper.class);
+ mockOutputWrapper = Mockito.mock(AppcLcmDmaapWrapper.class);
+ mockOperationOutcome = Mockito.mock(OperationOutcome.class);
+ mockResponseStatus = Mockito.mock(AppcLcmResponseStatus.class);
+ mockCommonHeader = Mockito.mock(AppcLcmCommonHeader.class);
+ mockParams = Mockito.mock(ControlLoopOperationParams.class);
+ operation = Mockito.mock(AppcLcmOperation.class);
+ }
+
+ @Test
+ public void testStartPreprocessorAsync() {
+ Mockito.doCallRealMethod().when(operation).startPreprocessorAsync();
+ assertNull(operation.startPreprocessorAsync());
+ }
+
+ @Ignore
+ @Test
+ public void testMakeRequest() {
+ UUID randomId = UUID.randomUUID();
+ Mockito.doCallRealMethod().when(operation).makeRequest(1, "sampleTargetVnf");
+ Mockito.when(mockParams.getRequestId()).thenReturn(randomId);
+ Mockito.when(mockParams.getPayload()).thenReturn(null);
+ Mockito.when(mockParams.getContext()).thenReturn(mockContext);
+ Mockito.when(mockParams.getOperation()).thenReturn("Config-Modify");
+ Mockito.when(mockContext.getEvent()).thenReturn(mockEvent);
+ Mockito.when(mockEvent.getRequestId()).thenReturn(randomId);
+ Whitebox.setInternalState(operation, "params", mockParams);
+ assertNotNull(operation.makeRequest(1, "sampleTargetVnf"));
+ Mockito.verify(mockParams, atLeast(1)).getRequestId();
+ Mockito.verify(mockParams, atLeast(1)).getPayload();
+ Mockito.verify(mockParams, atLeast(1)).getContext();
+ Mockito.verify(mockContext, atLeast(1)).getEvent();
+ Mockito.verify(mockEvent, atLeast(1)).getRequestId();
+ }
+
+ @Test
+ public void testGetExpectedKeyValues() {
+ Mockito.doCallRealMethod().when(operation).getExpectedKeyValues(1, mockInputWrapper);
+ Mockito.when(mockInputWrapper.getBody()).thenReturn(mockBody);
+ Mockito.when(mockBody.getInput()).thenReturn(mockInput);
+ Mockito.when(mockInput.getCommonHeader()).thenReturn(mockCommonHeader);
+ Mockito.when(mockCommonHeader.getSubRequestId()).thenReturn("sampleSubRequestId");
+
+ List<String> retList = operation.getExpectedKeyValues(1, mockInputWrapper);
+ assertNotNull(retList);
+ assertEquals(1, retList.size());
+
+ Mockito.verify(mockInputWrapper, atLeast(1)).getBody();
+ Mockito.verify(mockBody, atLeast(1)).getInput();
+ Mockito.verify(mockInput, atLeast(1)).getCommonHeader();
+ Mockito.verify(mockCommonHeader, atLeast(1)).getSubRequestId();
+ }
+
+ @Test
+ public void testDetmStatus() {
+ Mockito.doCallRealMethod().when(operation).detmStatus("testResponse", mockOutputWrapper);
+ Mockito.when(mockOutputWrapper.getBody()).thenReturn(mockBody);
+ Mockito.when(mockBody.getOutput()).thenReturn(mockOutput);
+ Mockito.when(mockOutput.getStatus()).thenReturn(mockResponseStatus);
+ Mockito.when(mockResponseStatus.getCode()).thenReturn(100);
+ Status retStatus = operation.detmStatus("testResponse", mockOutputWrapper);
+ assertEquals(Status.STILL_WAITING, retStatus);
+
+ Mockito.when(mockResponseStatus.getCode()).thenReturn(400);
+ retStatus = operation.detmStatus("testResponse", mockOutputWrapper);
+ assertEquals(Status.SUCCESS, retStatus);
+
+ Mockito.when(mockResponseStatus.getCode()).thenReturn(450);
+ retStatus = operation.detmStatus("testResponse", mockOutputWrapper);
+ assertEquals(Status.FAILURE, retStatus);
+
+ Mockito.when(mockOutput.getStatus()).thenReturn(null);
+ assertThatIllegalArgumentException().isThrownBy(() -> operation.detmStatus("testResponse", mockOutputWrapper));
+
+ Mockito.when(mockResponseStatus.getCode()).thenReturn(200);
+ assertThatIllegalArgumentException().isThrownBy(() -> operation.detmStatus("testResponse", mockOutputWrapper));
+
+ Mockito.verify(mockOutputWrapper, atLeast(1)).getBody();
+ Mockito.verify(mockBody, atLeast(1)).getOutput();
+ Mockito.verify(mockOutput, atLeast(1)).getStatus();
+ Mockito.verify(mockResponseStatus, atLeast(1)).getCode();
+ }
+
+ @Test
+ public void testSetOutcome() {
+ Mockito.doCallRealMethod().when(operation).setOutcome(mockOperationOutcome, PolicyResult.SUCCESS,
+ mockOutputWrapper);
+ Mockito.doCallRealMethod().when(operation).setOutcome(mockOperationOutcome, PolicyResult.FAILURE,
+ mockOutputWrapper);
+
+ Mockito.doCallRealMethod().when(mockOperationOutcome).setResult(any(PolicyResult.class));
+ Mockito.doCallRealMethod().when(mockOperationOutcome).setMessage(any(String.class));
+ Mockito.doCallRealMethod().when(mockOperationOutcome).getResult();
+ Mockito.doCallRealMethod().when(mockOperationOutcome).getMessage();
+
+ Mockito.when(mockOutputWrapper.getBody()).thenReturn(mockBody);
+ Mockito.when(mockBody.getOutput()).thenReturn(mockOutput);
+ Mockito.when(mockOutput.getStatus()).thenReturn(mockResponseStatus);
+ Mockito.when(mockResponseStatus.getMessage()).thenReturn(null);
+
+ OperationOutcome result = operation.setOutcome(mockOperationOutcome, PolicyResult.SUCCESS, mockOutputWrapper);
+ assertNull(result);
+ Mockito.verify(operation).setOutcome(mockOperationOutcome, PolicyResult.SUCCESS, mockOutputWrapper);
+
+ Mockito.when(mockOutput.getStatus()).thenReturn(mockResponseStatus);
+ Mockito.when(mockResponseStatus.getMessage()).thenReturn("sampleMessage");
+ result = operation.setOutcome(mockOperationOutcome, PolicyResult.FAILURE, mockOutputWrapper);
+ assertEquals(PolicyResult.FAILURE, result.getResult());
+ assertNotNull(result.getMessage());
+
+ Mockito.verify(mockOutputWrapper, atLeast(1)).getBody();
+ Mockito.verify(mockBody, atLeast(1)).getOutput();
+ Mockito.verify(mockOutput, atLeast(1)).getStatus();
+ Mockito.verify(mockResponseStatus, atLeast(1)).getMessage();
+ Mockito.verify(operation, atLeast(1)).setOutcome(mockOperationOutcome, PolicyResult.SUCCESS, mockOutputWrapper);
+ Mockito.verify(operation, atLeast(1)).setOutcome(mockOperationOutcome, PolicyResult.FAILURE, mockOutputWrapper);
+ }
+
+}
Code Review / policy / models.git / blobdiff