2 * ============LICENSE_START=======================================================
3 * Copyright (C) 2018 Ericsson. All rights reserved.
4 * ================================================================================
5 * Modifications Copyright (C) 2019 AT&T Intellectual Property
6 * ================================================================================
7 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use
8 * this file except in compliance with the License. You may obtain a copy of the License at
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software distributed under the License
13 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
14 * or implied. See the License for the specific language governing permissions and limitations under
17 * SPDX-License-Identifier: Apache-2.0
18 * ============LICENSE_END=========================================================
21 package org.onap.appc.requesthandler.impl;
23 import static org.mockito.Mockito.anyString;
24 import static org.mockito.Mockito.doNothing;
25 import static org.mockito.Mockito.doReturn;
26 import static org.mockito.Mockito.doThrow;
27 import static org.mockito.Mockito.mock;
28 import static org.mockito.Mockito.spy;
30 import com.att.eelf.configuration.EELFLogger;
31 import com.att.eelf.configuration.EELFLogger.Level;
32 import com.att.eelf.configuration.EELFManager;
33 import com.att.eelf.i18n.EELFResourceManager;
35 import java.util.Arrays;
36 import java.util.Date;
37 import java.util.List;
39 import org.junit.Before;
40 import org.junit.Test;
41 import org.junit.runner.RunWith;
42 import org.mockito.Mockito;
43 import org.onap.appc.domainmodel.lcm.ActionIdentifiers;
44 import org.onap.appc.domainmodel.lcm.CommonHeader;
45 import org.onap.appc.domainmodel.lcm.Flags;
46 import org.onap.appc.domainmodel.lcm.RequestContext;
47 import org.onap.appc.domainmodel.lcm.RequestStatus;
48 import org.onap.appc.domainmodel.lcm.ResponseContext;
49 import org.onap.appc.domainmodel.lcm.RuntimeContext;
50 import org.onap.appc.domainmodel.lcm.VNFContext;
51 import org.onap.appc.domainmodel.lcm.VNFOperation;
52 import org.onap.appc.exceptions.APPCException;
53 import org.onap.appc.executor.CommandExecutor;
54 import org.onap.appc.executor.objects.CommandExecutorInput;
55 import org.onap.appc.executor.objects.LCMCommandStatus;
56 import org.onap.appc.executor.objects.Params;
57 import org.onap.appc.i18n.Msg;
58 import org.onap.appc.lockmanager.api.LockException;
59 import org.onap.appc.lockmanager.api.LockManager;
60 import org.onap.appc.logging.LoggingConstants;
61 import org.onap.appc.metricservice.MetricRegistry;
62 import org.onap.appc.metricservice.impl.MetricRegistryImpl;
63 import org.onap.appc.metricservice.metric.MetricType;
64 import org.onap.appc.metricservice.metric.impl.DispatchingFuntionMetricImpl;
65 import org.onap.appc.transactionrecorder.TransactionRecorder;
66 import org.osgi.framework.FrameworkUtil;
67 import org.powermock.api.mockito.PowerMockito;
68 import org.powermock.core.classloader.annotations.PrepareForTest;
69 import org.powermock.modules.junit4.PowerMockRunner;
70 import org.powermock.reflect.Whitebox;
72 @RunWith(PowerMockRunner.class)
73 @PrepareForTest({ FrameworkUtil.class })
74 public class RequestHandlerImplTest implements LocalRequestHanlderTestHelper {
76 private RequestHandlerImpl requestHandler;
77 private TransactionRecorder recorder;
78 private LockManager lockManager;
81 public void setUp() throws Exception {
82 setupForHandlerImplTests();
83 requestHandler = PowerMockito.spy(new RequestHandlerImpl());
84 recorder = mock(TransactionRecorder.class);
85 requestHandler.setTransactionRecorder(recorder);
86 lockManager = mock(LockManager.class);
87 requestHandler.setLockManager(lockManager);
88 List<RequestStatus> result = Arrays.asList(RequestStatus.ACCEPTED);
89 PowerMockito.when(recorder.getRecords(anyString(), anyString(), anyString(), anyString()))
91 final EELFLogger logger = EELFManager.getInstance().getLogger(RequestHandlerImpl.class);
92 logger.setLevel(Level.TRACE);
93 Whitebox.setInternalState(requestHandler, "logger", logger);
97 public void testHandleRequestRuntimeContext() {
98 Whitebox.setInternalState(requestHandler, "isMetricEnabled", true);
99 MetricRegistry metricRegistry = spy(new MetricRegistryImpl("TEST_METRIC_REGISTRY"));
100 DispatchingFuntionMetricImpl metric = spy(
101 new DispatchingFuntionMetricImpl("DISPATCH_FUNCTION", MetricType.COUNTER, 0, 0));
102 metricRegistry.register(metric);
103 doNothing().when(metric).incrementAcceptedRequest();
104 Whitebox.setInternalState(RequestHandlerImpl.class, "metricRegistry", metricRegistry);
105 RuntimeContext runtimeContext = spy(new RuntimeContext());
106 RequestContext requestContext = setupRequestContext();
107 runtimeContext.setRequestContext(requestContext);
108 CommonHeader ch = getCommonHeader("TEST", new Date(System.currentTimeMillis()));
109 requestContext.setCommonHeader(ch);
110 CommandExecutor commandExecutor = mock(CommandExecutor.class);
111 requestHandler.setCommandExecutor(commandExecutor);
112 doNothing().when(requestHandler).fillStatus(Mockito.any(RuntimeContext.class),
113 Mockito.any(LCMCommandStatus.class), Mockito.any());
114 requestHandler.handleRequest(runtimeContext);
115 Mockito.verify(requestHandler).fillStatus(runtimeContext, LCMCommandStatus.ACCEPTED, null);
119 public void testHandleRequestRuntimeContextNegativeTTL() {
120 RuntimeContext runtimeContext = spy(new RuntimeContext());
121 RequestContext requestContext = setupRequestContext();
122 runtimeContext.setRequestContext(requestContext);
123 CommonHeader ch = getCommonHeader("TEST", new Date(System.currentTimeMillis() - 100000));
124 requestContext.setCommonHeader(ch);
125 CommandExecutor commandExecutor = mock(CommandExecutor.class);
126 requestHandler.setCommandExecutor(commandExecutor);
127 doNothing().when(requestHandler).fillStatus(Mockito.any(RuntimeContext.class),
128 Mockito.any(LCMCommandStatus.class), Mockito.any());
129 doNothing().when(requestHandler).storeErrorMessageToLog(Mockito.any(RuntimeContext.class), Mockito.anyString(),
130 Mockito.anyString(), Mockito.anyString());
131 requestHandler.handleRequest(runtimeContext);
132 Mockito.verify(requestHandler).fillStatus(runtimeContext, LCMCommandStatus.EXPIRED_REQUEST, null);
137 public void testHandleRequestRuntimeContextAPPCException() throws APPCException {
138 RuntimeContext runtimeContext = spy(new RuntimeContext());
139 RequestContext requestContext = setupRequestContext();
140 runtimeContext.setRequestContext(requestContext);
141 CommonHeader ch = getCommonHeader("TEST", new Date(System.currentTimeMillis()));
142 requestContext.setCommonHeader(ch);
143 CommandExecutor commandExecutor = mock(CommandExecutor.class);
144 requestHandler.setCommandExecutor(commandExecutor);
145 doNothing().when(requestHandler).fillStatus(Mockito.any(RuntimeContext.class),
146 Mockito.any(LCMCommandStatus.class), Mockito.any());
147 doThrow(new APPCException("TEST_APPC_EXCEPTION")).when(commandExecutor)
148 .executeCommand(Mockito.any(CommandExecutorInput.class));
149 doNothing().when(requestHandler).storeErrorMessageToLog(Mockito.any(RuntimeContext.class), Mockito.anyString(),
150 Mockito.anyString(), Mockito.anyString());
151 requestHandler.handleRequest(runtimeContext);
152 Mockito.verify(requestHandler).fillStatus(Mockito.any(RuntimeContext.class),
153 Mockito.any(LCMCommandStatus.class), Mockito.any(Params.class));
157 public void testHandleRequestRuntimeContextCaseLock() throws LockException {
158 RuntimeContext runtimeContext = spy(new RuntimeContext());
159 RequestContext requestContext = new RequestContext();
160 requestContext.setAction(VNFOperation.Lock);
161 runtimeContext.setRequestContext(requestContext);
162 VNFContext vnfContext = new VNFContext();
163 vnfContext.setId("TEST_VNF_CONTEXT_ID");
164 runtimeContext.setVnfContext(vnfContext);
165 CommonHeader ch = getCommonHeader("TEST", new Date(System.currentTimeMillis()));
166 requestContext.setCommonHeader(ch);
167 CommandExecutor commandExecutor = mock(CommandExecutor.class);
168 requestHandler.setCommandExecutor(commandExecutor);
169 doNothing().when(requestHandler).fillStatus(Mockito.any(RuntimeContext.class),
170 Mockito.any(LCMCommandStatus.class), Mockito.any());
171 doReturn(true).when(lockManager).acquireLock(Mockito.anyString(), Mockito.anyString(), Mockito.anyLong());
172 requestHandler.handleRequest(runtimeContext);
173 Mockito.verify(requestHandler).fillStatus(runtimeContext, LCMCommandStatus.SUCCESS, null);
177 public void testHandleRequestRuntimeContextLockError() throws LockException {
178 RuntimeContext runtimeContext = spy(new RuntimeContext());
179 RequestContext requestContext = new RequestContext();
180 requestContext.setAction(VNFOperation.Lock);
181 runtimeContext.setRequestContext(requestContext);
182 VNFContext vnfContext = new VNFContext();
183 vnfContext.setId("TEST_VNF_CONTEXT_ID");
184 runtimeContext.setVnfContext(vnfContext);
185 CommonHeader ch = getCommonHeader("TEST", new Date(System.currentTimeMillis()));
186 requestContext.setCommonHeader(ch);
187 CommandExecutor commandExecutor = mock(CommandExecutor.class);
188 requestHandler.setCommandExecutor(commandExecutor);
189 doNothing().when(requestHandler).fillStatus(Mockito.any(RuntimeContext.class),
190 Mockito.any(LCMCommandStatus.class), Mockito.any());
191 doThrow(new LockException("TEST_LOCK_EXCEPTION")).when(lockManager).acquireLock(Mockito.anyString(),
192 Mockito.anyString(), Mockito.anyLong());
193 doNothing().when(requestHandler).storeErrorMessageToLog(Mockito.any(RuntimeContext.class), Mockito.anyString(),
194 Mockito.anyString(), Mockito.anyString());
195 requestHandler.handleRequest(runtimeContext);
196 Mockito.verify(requestHandler).storeErrorMessageToLog(runtimeContext, LoggingConstants.TargetNames.APPC,
197 LoggingConstants.TargetNames.LOCK_MANAGER,
198 EELFResourceManager.format(Msg.VF_SERVER_BUSY, "TEST_VNF_CONTEXT_ID"));
202 public void testHandleRequestRuntimeContextCaseUnlock() throws LockException {
203 RuntimeContext runtimeContext = spy(new RuntimeContext());
204 RequestContext requestContext = new RequestContext();
205 requestContext.setAction(VNFOperation.Unlock);
206 runtimeContext.setRequestContext(requestContext);
207 VNFContext vnfContext = new VNFContext();
208 vnfContext.setId("TEST_VNF_CONTEXT_ID");
209 runtimeContext.setVnfContext(vnfContext);
210 CommonHeader ch = getCommonHeader("TEST", new Date(System.currentTimeMillis()));
211 requestContext.setCommonHeader(ch);
212 CommandExecutor commandExecutor = mock(CommandExecutor.class);
213 requestHandler.setCommandExecutor(commandExecutor);
214 doNothing().when(requestHandler).fillStatus(Mockito.any(RuntimeContext.class),
215 Mockito.any(LCMCommandStatus.class), Mockito.any());
216 doReturn(true).when(lockManager).acquireLock(Mockito.anyString(), Mockito.anyString(), Mockito.anyLong());
217 requestHandler.handleRequest(runtimeContext);
218 Mockito.verify(requestHandler).fillStatus(runtimeContext, LCMCommandStatus.SUCCESS, null);
222 public void testHandleRequestRuntimeContextUnlockError() throws LockException {
223 RuntimeContext runtimeContext = spy(new RuntimeContext());
224 RequestContext requestContext = new RequestContext();
225 requestContext.setAction(VNFOperation.Unlock);
226 runtimeContext.setRequestContext(requestContext);
227 VNFContext vnfContext = new VNFContext();
228 vnfContext.setId("TEST_VNF_CONTEXT_ID");
229 runtimeContext.setVnfContext(vnfContext);
230 CommonHeader ch = getCommonHeader("TEST", new Date(System.currentTimeMillis()));
231 requestContext.setCommonHeader(ch);
232 CommandExecutor commandExecutor = mock(CommandExecutor.class);
233 requestHandler.setCommandExecutor(commandExecutor);
234 doNothing().when(requestHandler).fillStatus(Mockito.any(RuntimeContext.class),
235 Mockito.any(LCMCommandStatus.class), Mockito.any());
236 doThrow(new LockException("TEST_LOCK_EXCEPTION")).when(lockManager).releaseLock(Mockito.anyString(),
237 Mockito.anyString());
238 doNothing().when(requestHandler).storeErrorMessageToLog(Mockito.any(RuntimeContext.class), Mockito.anyString(),
239 Mockito.anyString(), Mockito.anyString());
240 requestHandler.handleRequest(runtimeContext);
241 Mockito.verify(requestHandler).fillStatus(Mockito.any(RuntimeContext.class),
242 Mockito.any(LCMCommandStatus.class), Mockito.any(Params.class));
246 public void testHandleRequestRuntimeContextCaseCheckLock() {
247 RuntimeContext runtimeContext = spy(new RuntimeContext());
248 RequestContext requestContext = new RequestContext();
249 ResponseContext responseContext = spy(new ResponseContext());
250 runtimeContext.setResponseContext(responseContext);
251 requestContext.setAction(VNFOperation.CheckLock);
252 runtimeContext.setRequestContext(requestContext);
253 VNFContext vnfContext = new VNFContext();
254 vnfContext.setId("TEST_VNF_CONTEXT_ID");
255 runtimeContext.setVnfContext(vnfContext);
256 CommonHeader ch = getCommonHeader("TEST", new Date(System.currentTimeMillis()));
257 requestContext.setCommonHeader(ch);
258 CommandExecutor commandExecutor = mock(CommandExecutor.class);
259 requestHandler.setCommandExecutor(commandExecutor);
260 doNothing().when(requestHandler).fillStatus(Mockito.any(RuntimeContext.class),
261 Mockito.any(LCMCommandStatus.class), Mockito.any());
262 doReturn(true).when(lockManager).isLocked("TEST_VNF_CONTEXT_ID");
263 requestHandler.handleRequest(runtimeContext);
264 Mockito.verify(responseContext).addKeyValueToAdditionalContext("locked", String.valueOf(true).toUpperCase());
267 private RequestContext setupRequestContext() {
268 RequestContext requestContext = new RequestContext();
269 requestContext.setAction(VNFOperation.ActionStatus);
270 ActionIdentifiers actionIdentifiers = new ActionIdentifiers();
271 actionIdentifiers.setVnfId("TEST_VNF_ID");
272 requestContext.setActionIdentifiers(actionIdentifiers);
273 return requestContext;