2 * ============LICENSE_START==========================================
4 * ===================================================================
5 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
6 * ===================================================================
8 * Unless otherwise specified, all software contained herein is licensed
9 * under the Apache License, Version 2.0 (the "License");
10 * you may not use this software except in compliance with the License.
11 * You may obtain a copy of the License at
13 * http://www.apache.org/licenses/LICENSE-2.0
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.
21 * Unless otherwise specified, all documentation contained herein is licensed
22 * under the Creative Commons License, Attribution 4.0 Intl. (the "License");
23 * you may not use this documentation except in compliance with the License.
24 * You may obtain a copy of the License at
26 * https://creativecommons.org/licenses/by/4.0/
28 * Unless required by applicable law or agreed to in writing, documentation
29 * distributed under the License is distributed on an "AS IS" BASIS,
30 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
31 * See the License for the specific language governing permissions and
32 * limitations under the License.
34 * ============LICENSE_END============================================
37 package org.onap.portalapp.portal.controller;
39 import static org.junit.Assert.*;
41 import java.lang.reflect.Method;
42 import java.util.ArrayList;
43 import java.util.HashMap;
44 import java.util.List;
47 import javax.servlet.http.HttpServletRequest;
48 import javax.servlet.http.HttpServletResponse;
50 import org.junit.Before;
51 import org.junit.Test;
52 import org.junit.runner.RunWith;
53 import org.mockito.InjectMocks;
54 import org.mockito.Matchers;
55 import org.mockito.Mock;
56 import org.mockito.Mockito;
57 import org.mockito.MockitoAnnotations;
58 import org.onap.portalapp.annotation.ApiVersion;
59 import org.onap.portalapp.controller.sessionmgt.SessionCommunicationController;
60 import org.onap.portalapp.controller.sessionmgt.SessionCommunicationVersionController;
61 import org.onap.portalapp.externalsystemapproval.model.ExternalSystemUser;
62 import org.onap.portalapp.portal.domain.EPUser;
63 import org.onap.portalapp.portal.ecomp.model.PortalRestResponse;
64 import org.onap.portalapp.portal.ecomp.model.PortalRestStatusEnum;
65 import org.onap.portalapp.portal.framework.MockitoTestSuite;
66 import org.onap.portalapp.portal.transport.Analytics;
67 import org.onap.portalapp.portal.transport.EpNotificationItem;
68 import org.onap.portalapp.portal.transport.OnboardingApp;
69 import org.onap.portalsdk.core.domain.Role;
70 import org.powermock.api.mockito.PowerMockito;
71 import org.powermock.core.classloader.annotations.PrepareForTest;
72 import org.powermock.modules.junit4.PowerMockRunner;
73 import org.springframework.aop.support.AopUtils;
74 import org.springframework.context.ApplicationContext;
76 @RunWith(PowerMockRunner.class)
77 @PrepareForTest(AopUtils.class)
78 public class AuxApiRequestMapperControllerTest {
80 AuxApiRequestMapperController auxApiRequestMapperController = new AuxApiRequestMapperController();
84 MockitoAnnotations.initMocks(this);
87 RolesController rolesController = new RolesController();
88 SessionCommunicationVersionController sessionCommunicationController = new SessionCommunicationVersionController();
89 WebAnalyticsExtAppVersionController webAnalyticsExtAppController = new WebAnalyticsExtAppVersionController();
90 RolesApprovalSystemVersionController rolesApprovalSystemController = new RolesApprovalSystemVersionController();
91 TicketEventVersionController ticketEventVersionController = new TicketEventVersionController();
92 AppsControllerExternalVersionRequest appsControllerExternalVersionRequest = new AppsControllerExternalVersionRequest();
93 ExternalAppsRestfulVersionController externalAppsRestfulVersionController = new ExternalAppsRestfulVersionController();
96 ApplicationContext context;
99 MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
100 HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
101 HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
102 NullPointerException nullPointerException = new NullPointerException();
105 public void getUserTest() throws Exception {
106 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/roles");
107 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
108 Map<String, Object> beans = new HashMap<>();
109 beans.put("bean1", rolesController);
110 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
111 PowerMockito.mockStatic(AopUtils.class);
112 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
113 Mockito.when(mockedRequest.getMethod()).thenReturn("GET");
114 assertNull(auxApiRequestMapperController.getUser(mockedRequest, mockedResponse, "test12"));
118 public void getRolesTest() throws Exception {
119 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/roles");
120 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
121 Map<String, Object> beans = new HashMap<>();
122 beans.put("bean1", rolesController);
123 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
124 PowerMockito.mockStatic(AopUtils.class);
125 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
126 Mockito.when(mockedRequest.getMethod()).thenReturn("GET");
127 assertNull(auxApiRequestMapperController.getRoles(mockedRequest, mockedResponse));
131 public void saveRoleTest() throws Exception {
132 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/role");
133 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
134 Map<String, Object> beans = new HashMap<>();
135 beans.put("bean1", rolesController);
136 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
137 PowerMockito.mockStatic(AopUtils.class);
138 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
139 Mockito.when(mockedRequest.getMethod()).thenReturn("POST");
140 Role role = new Role();
141 assertNull(auxApiRequestMapperController.saveRole(mockedRequest, mockedResponse, role));
145 public void getEPRolesTest() throws Exception {
146 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v4/roles");
147 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
148 Map<String, Object> beans = new HashMap<>();
149 beans.put("bean1", rolesController);
150 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
151 PowerMockito.mockStatic(AopUtils.class);
152 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
153 Mockito.when(mockedRequest.getMethod()).thenReturn("GET");
154 assertNull(auxApiRequestMapperController.getRoles(mockedRequest, mockedResponse));
158 public void getUser1Test() throws Exception {
159 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/user/test12");
160 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
161 Map<String, Object> beans = new HashMap<>();
162 beans.put("bean1", rolesController);
163 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
164 PowerMockito.mockStatic(AopUtils.class);
165 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
166 Mockito.when(mockedRequest.getMethod()).thenReturn("GET");
167 assertNull(auxApiRequestMapperController.getUser(mockedRequest, mockedResponse, "test12"));
171 public void getRoleTest() throws Exception {
172 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/role/1");
173 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
174 Map<String, Object> beans = new HashMap<>();
175 beans.put("bean1", rolesController);
176 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
177 PowerMockito.mockStatic(AopUtils.class);
178 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
179 Mockito.when(mockedRequest.getMethod()).thenReturn("GET");
180 assertNull(auxApiRequestMapperController.getRoleInfo(mockedRequest, mockedResponse, (long) 1));
184 public void getUsersOfApplicationTest() throws Exception {
185 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/users");
186 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
187 Map<String, Object> beans = new HashMap<>();
188 beans.put("bean1", rolesController);
189 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
190 PowerMockito.mockStatic(AopUtils.class);
191 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
192 Mockito.when(mockedRequest.getMethod()).thenReturn("GET");
193 assertNull(auxApiRequestMapperController.getUsersOfApplication(mockedRequest, mockedResponse));
197 public void getRoleFunctionsListTest() throws Exception {
198 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/functions");
199 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
200 Map<String, Object> beans = new HashMap<>();
201 beans.put("bean1", rolesController);
202 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
203 PowerMockito.mockStatic(AopUtils.class);
204 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
205 Mockito.when(mockedRequest.getMethod()).thenReturn("GET");
206 assertNull(auxApiRequestMapperController.getRoleFunctionsList(mockedRequest, mockedResponse));
210 public void getRoleFunctionTest() throws Exception {
211 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/function/test");
212 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
213 Map<String, Object> beans = new HashMap<>();
214 beans.put("bean1", rolesController);
215 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
216 PowerMockito.mockStatic(AopUtils.class);
217 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
218 Mockito.when(mockedRequest.getMethod()).thenReturn("GET");
219 assertNull(auxApiRequestMapperController.getRoleFunction(mockedRequest, mockedResponse, "test"));
223 public void saveRoleFunctionTest() throws Exception {
224 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/roleFunction");
225 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
226 Map<String, Object> beans = new HashMap<>();
227 beans.put("bean1", rolesController);
228 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
229 PowerMockito.mockStatic(AopUtils.class);
230 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
231 Mockito.when(mockedRequest.getMethod()).thenReturn("POST");
232 PortalRestResponse<String> response = auxApiRequestMapperController.saveRoleFunction(mockedRequest, mockedResponse, "test");
233 assertNotNull(response);
237 public void deleteRoleFunctionTest() throws Exception {
238 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/roleFunction/test");
239 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
240 Map<String, Object> beans = new HashMap<>();
241 beans.put("bean1", rolesController);
242 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
243 PowerMockito.mockStatic(AopUtils.class);
244 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
245 Mockito.when(mockedRequest.getMethod()).thenReturn("DELETE");
246 assertNull(auxApiRequestMapperController.deleteRoleFunction(mockedRequest, mockedResponse, "test"));
250 public void deleteRoleTest() throws Exception {
251 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/deleteRole/1");
252 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
253 Map<String, Object> beans = new HashMap<>();
254 beans.put("bean1", rolesController);
255 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
256 PowerMockito.mockStatic(AopUtils.class);
257 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
258 Mockito.when(mockedRequest.getMethod()).thenReturn("DELETE");
259 assertNull(auxApiRequestMapperController.deleteRole(mockedRequest, mockedResponse, (long) 1));
263 public void getActiveRolesTest() throws Exception {
264 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/activeRoles");
265 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
266 Map<String, Object> beans = new HashMap<>();
267 beans.put("bean1", rolesController);
268 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
269 PowerMockito.mockStatic(AopUtils.class);
270 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
271 Mockito.when(mockedRequest.getMethod()).thenReturn("GET");
272 assertNull(auxApiRequestMapperController.getActiveRoles(mockedRequest, mockedResponse));
276 public void getEcompUserTest() throws Exception {
277 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v4/user/test");
278 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
279 Map<String, Object> beans = new HashMap<>();
280 beans.put("bean1", rolesController);
281 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
282 PowerMockito.mockStatic(AopUtils.class);
283 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
284 Mockito.when(mockedRequest.getMethod()).thenReturn("GET");
285 assertNull(auxApiRequestMapperController.getEcompUser(mockedRequest, mockedResponse, "test"));
289 public void getEcompRolesOfApplicationTest() throws Exception {
290 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v4/roles");
291 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
292 Map<String, Object> beans = new HashMap<>();
293 beans.put("bean1", rolesController);
294 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
295 PowerMockito.mockStatic(AopUtils.class);
296 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
297 Mockito.when(mockedRequest.getMethod()).thenReturn("GET");
298 assertNull(auxApiRequestMapperController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
302 public void getSessionSlotCheckIntervalTest() throws Exception {
303 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/getSessionSlotCheckInterval");
304 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
305 Map<String, Object> beans = new HashMap<>();
306 beans.put("bean1", sessionCommunicationController);
307 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
308 PowerMockito.mockStatic(AopUtils.class);
309 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
310 Mockito.when(mockedRequest.getMethod()).thenReturn("GET");
311 assertNull(auxApiRequestMapperController.getSessionSlotCheckInterval(mockedRequest, mockedResponse));
315 public void extendSessionTimeOutsTest() throws Exception {
316 String sessionMap = "test";
317 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/extendSessionTimeOuts");
318 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
319 Map<String, Object> beans = new HashMap<>();
320 beans.put("bean1", sessionCommunicationController);
321 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
322 PowerMockito.mockStatic(AopUtils.class);
323 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
324 Mockito.when(mockedRequest.getMethod()).thenReturn("POST");
325 assertNull(auxApiRequestMapperController.extendSessionTimeOuts(mockedRequest, mockedResponse, sessionMap));
329 public void getAnalyticsScriptTest() throws Exception {
330 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/analytics");
331 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
332 Map<String, Object> beans = new HashMap<>();
333 beans.put("bean1", webAnalyticsExtAppController);
334 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
335 PowerMockito.mockStatic(AopUtils.class);
336 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
337 Mockito.when(mockedRequest.getMethod()).thenReturn("GET");
338 assertNull(auxApiRequestMapperController.getAnalyticsScript(mockedRequest, mockedResponse));
342 public void storeAnalyticsScriptTest() throws Exception {
343 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/storeAnalytics");
344 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
345 Map<String, Object> beans = new HashMap<>();
346 beans.put("bean1", webAnalyticsExtAppController);
347 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
348 PowerMockito.mockStatic(AopUtils.class);
349 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
350 Mockito.when(mockedRequest.getMethod()).thenReturn("POST");
351 Analytics analyticsMap = new Analytics();
352 assertNull(auxApiRequestMapperController.storeAnalyticsScript(mockedRequest, mockedResponse, analyticsMap));
356 public void bulkUploadFunctionsTest() throws Exception {
357 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/upload/portal/functions");
358 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
359 Map<String, Object> beans = new HashMap<>();
360 beans.put("bean1", rolesController);
361 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
362 PowerMockito.mockStatic(AopUtils.class);
363 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
364 Mockito.when(mockedRequest.getMethod()).thenReturn("POST");
365 PortalRestResponse res = new PortalRestResponse();
366 res.setStatus(PortalRestStatusEnum.ERROR);
367 res.setMessage("Failed to bulkUploadFunctions");
368 res.setResponse("Failed");
369 assertEquals(res, auxApiRequestMapperController.bulkUploadFunctions(mockedRequest, mockedResponse));
373 public void bulkUploadRolesTest() throws Exception {
374 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/upload/portal/roles");
375 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
376 Map<String, Object> beans = new HashMap<>();
377 beans.put("bean1", rolesController);
378 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
379 PowerMockito.mockStatic(AopUtils.class);
380 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
381 Mockito.when(mockedRequest.getMethod()).thenReturn("POST");
382 PortalRestResponse res = new PortalRestResponse();
383 res.setStatus(PortalRestStatusEnum.ERROR);
384 res.setMessage("Failed to bulkUploadRoles");
385 res.setResponse("Failed");
386 assertEquals(res, auxApiRequestMapperController.bulkUploadRoles(mockedRequest, mockedResponse));
390 public void bulkUploadRoleFunctionsTest() throws Exception {
391 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/upload/portal/roleFunctions");
392 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
393 Map<String, Object> beans = new HashMap<>();
394 beans.put("bean1", rolesController);
395 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
396 PowerMockito.mockStatic(AopUtils.class);
397 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
398 Mockito.when(mockedRequest.getMethod()).thenReturn("POST");
399 PortalRestResponse res = new PortalRestResponse();
400 res.setStatus(PortalRestStatusEnum.ERROR);
401 res.setMessage("Failed to bulkUploadRoleFunctions");
402 res.setResponse("Failed");
403 assertEquals(res, auxApiRequestMapperController.bulkUploadRoleFunctions(mockedRequest, mockedResponse));
407 public void bulkUploadUserRolesTest() throws Exception {
408 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/upload/portal/userRoles");
409 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
410 Map<String, Object> beans = new HashMap<>();
411 beans.put("bean1", rolesController);
412 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
413 PowerMockito.mockStatic(AopUtils.class);
414 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
415 Mockito.when(mockedRequest.getMethod()).thenReturn("POST");
416 PortalRestResponse res = new PortalRestResponse();
417 res.setStatus(PortalRestStatusEnum.ERROR);
418 res.setMessage("Failed to bulkUploadUserRoles");
419 res.setResponse("Failed");
420 assertEquals(res, auxApiRequestMapperController.bulkUploadUserRoles(mockedRequest, mockedResponse));
424 public void bulkUploadUsersSingleRoleTest() throws Exception {
425 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/upload/portal/userRole/1");
426 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
427 Map<String, Object> beans = new HashMap<>();
428 beans.put("bean1", rolesController);
429 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
430 PowerMockito.mockStatic(AopUtils.class);
431 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
432 Mockito.when(mockedRequest.getMethod()).thenReturn("POST");
433 PortalRestResponse res = new PortalRestResponse();
434 res.setStatus(PortalRestStatusEnum.ERROR);
435 res.setMessage("Failed to bulkUploadUsersSingleRole");
436 res.setResponse("Failed");
438 auxApiRequestMapperController.bulkUploadUsersSingleRole(mockedRequest, mockedResponse, (long) 1));
442 public void bulkUploadPartnerFunctionsTest() throws Exception {
443 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/upload/partner/roleFunctions");
444 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
445 Map<String, Object> beans = new HashMap<>();
446 beans.put("bean1", rolesController);
447 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
448 PowerMockito.mockStatic(AopUtils.class);
449 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
450 Mockito.when(mockedRequest.getMethod()).thenReturn("POST");
451 PortalRestResponse res = new PortalRestResponse();
452 res.setStatus(PortalRestStatusEnum.ERROR);
453 res.setMessage("Failed to bulkUploadPartnerRoleFunctions");
454 res.setResponse("Failed");
455 assertEquals(res, auxApiRequestMapperController.bulkUploadPartnerFunctions(mockedRequest, mockedResponse));
459 public void bulkUploadPartnerRolesTest() throws Exception {
460 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/upload/partner/roles");
461 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
462 Map<String, Object> beans = new HashMap<>();
463 beans.put("bean1", rolesController);
464 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
465 PowerMockito.mockStatic(AopUtils.class);
466 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
467 Mockito.when(mockedRequest.getMethod()).thenReturn("POST");
468 List<Role> upload = new ArrayList<>();
469 PortalRestResponse res = new PortalRestResponse();
470 res.setStatus(PortalRestStatusEnum.ERROR);
471 res.setMessage("Failed to bulkUploadRoles");
472 res.setResponse("Failed");
473 assertEquals(res, auxApiRequestMapperController.bulkUploadPartnerRoles(mockedRequest, mockedResponse, upload));
477 public void bulkUploadPartnerRoleFunctionsTest() throws Exception {
478 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/upload/partner/roleFunctions");
479 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
480 Map<String, Object> beans = new HashMap<>();
481 beans.put("bean1", rolesController);
482 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
483 PowerMockito.mockStatic(AopUtils.class);
484 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
485 Mockito.when(mockedRequest.getMethod()).thenReturn("POST");
486 PortalRestResponse res = new PortalRestResponse();
487 res.setStatus(PortalRestStatusEnum.ERROR);
488 res.setMessage("Failed to bulkUploadPartnerRoleFunctions");
489 res.setResponse("Failed");
490 assertEquals(res, auxApiRequestMapperController.bulkUploadPartnerRoleFunctions(mockedRequest, mockedResponse));
494 public void getMenuFunctionsTest() throws Exception {
495 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/menuFunctions");
496 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
497 Map<String, Object> beans = new HashMap<>();
498 beans.put("bean1", rolesController);
499 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
500 PowerMockito.mockStatic(AopUtils.class);
501 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
502 Mockito.when(mockedRequest.getMethod()).thenReturn("GET");
503 assertNull(auxApiRequestMapperController.getMenuFunctions(mockedRequest, mockedResponse));
507 public void postUserProfileTest() throws Exception {
508 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/userProfile");
509 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
510 Map<String, Object> beans = new HashMap<>();
511 beans.put("bean1", rolesApprovalSystemController);
512 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
513 PowerMockito.mockStatic(AopUtils.class);
514 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
515 Mockito.when(mockedRequest.getMethod()).thenReturn("POST");
516 ExternalSystemUser extSysUser = new ExternalSystemUser();
517 assertNull(auxApiRequestMapperController.postUserProfile(mockedRequest, extSysUser, mockedResponse));
521 public void putUserProfileTest() throws Exception {
522 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/userProfile");
523 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
524 Map<String, Object> beans = new HashMap<>();
525 beans.put("bean1", rolesApprovalSystemController);
526 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
527 PowerMockito.mockStatic(AopUtils.class);
528 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
529 Mockito.when(mockedRequest.getMethod()).thenReturn("PUT");
530 ExternalSystemUser extSysUser = new ExternalSystemUser();
531 assertNull(auxApiRequestMapperController.putUserProfile(mockedRequest, extSysUser, mockedResponse));
535 public void deleteUserProfileTest() throws Exception {
536 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/userProfile");
537 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
538 Map<String, Object> beans = new HashMap<>();
539 beans.put("bean1", rolesApprovalSystemController);
540 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
541 PowerMockito.mockStatic(AopUtils.class);
542 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
543 Mockito.when(mockedRequest.getMethod()).thenReturn("DELETE");
544 ExternalSystemUser extSysUser = new ExternalSystemUser();
545 assertNull(auxApiRequestMapperController.deleteUserProfile(mockedRequest, extSysUser, mockedResponse));
549 public void handleRequestTest() throws Exception {
550 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/ticketevent");
551 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
552 Map<String, Object> beans = new HashMap<>();
553 beans.put("bean1", ticketEventVersionController);
554 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
555 PowerMockito.mockStatic(AopUtils.class);
556 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
557 Mockito.when(mockedRequest.getMethod()).thenReturn("POST");
558 assertNull(auxApiRequestMapperController.handleRequest(mockedRequest, mockedResponse, "test"));
562 public void postPortalAdminTest() throws Exception {
563 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/portalAdmin");
564 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
565 Map<String, Object> beans = new HashMap<>();
566 beans.put("bean1", appsControllerExternalVersionRequest);
567 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
568 PowerMockito.mockStatic(AopUtils.class);
569 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
570 Mockito.when(mockedRequest.getMethod()).thenReturn("POST");
571 EPUser epUser = new EPUser();
572 assertNull(auxApiRequestMapperController.postPortalAdmin(mockedRequest, mockedResponse, epUser));
576 public void getOnboardAppExternalTest() throws Exception {
577 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/onboardApp/1");
578 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
579 Map<String, Object> beans = new HashMap<>();
580 beans.put("bean1", appsControllerExternalVersionRequest);
581 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
582 PowerMockito.mockStatic(AopUtils.class);
583 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
584 Mockito.when(mockedRequest.getMethod()).thenReturn("GET");
585 assertNull(auxApiRequestMapperController.getOnboardAppExternal(mockedRequest, mockedResponse, (long) 1));
589 public void postOnboardAppExternalTest() throws Exception {
590 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/onboardApp");
591 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
592 Map<String, Object> beans = new HashMap<>();
593 beans.put("bean1", appsControllerExternalVersionRequest);
594 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
595 PowerMockito.mockStatic(AopUtils.class);
596 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
597 Mockito.when(mockedRequest.getMethod()).thenReturn("POST");
598 OnboardingApp newOnboardApp = new OnboardingApp();
599 assertNull(auxApiRequestMapperController.postOnboardAppExternal(mockedRequest, mockedResponse, newOnboardApp));
603 public void putOnboardAppExternalTest() throws Exception {
604 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/onboardApp/1");
605 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
606 Map<String, Object> beans = new HashMap<>();
607 beans.put("bean1", appsControllerExternalVersionRequest);
608 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
609 PowerMockito.mockStatic(AopUtils.class);
610 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
611 Mockito.when(mockedRequest.getMethod()).thenReturn("PUT");
612 OnboardingApp newOnboardApp = new OnboardingApp();
613 assertNull(auxApiRequestMapperController.putOnboardAppExternal(mockedRequest, mockedResponse, (long) 1,
618 public void publishNotificationTest() throws Exception {
619 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/publishNotification");
620 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
621 Map<String, Object> beans = new HashMap<>();
622 beans.put("bean1", externalAppsRestfulVersionController);
623 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
624 PowerMockito.mockStatic(AopUtils.class);
625 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
626 Mockito.when(mockedRequest.getMethod()).thenReturn("POST");
627 EpNotificationItem notificationItem = new EpNotificationItem();
628 assertNull(auxApiRequestMapperController.publishNotification(mockedRequest, notificationItem, mockedResponse));
632 public void getFavoritesForUserTest() throws Exception {
633 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/getFavorites");
634 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
635 Map<String, Object> beans = new HashMap<>();
636 beans.put("bean1", externalAppsRestfulVersionController);
637 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
638 PowerMockito.mockStatic(AopUtils.class);
639 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
640 Mockito.when(mockedRequest.getMethod()).thenReturn("GET");
641 assertNull(auxApiRequestMapperController.getFavoritesForUser(mockedRequest, mockedResponse));
645 public void functionalMenuItemsForUserTest() throws Exception {
646 Mockito.when(mockedRequest.getRequestURI()).thenReturn("/auxapi/v3/functionalMenuItemsForUser");
647 Mockito.when(mockedRequest.getHeader("MinorVersion")).thenReturn("0");
648 Map<String, Object> beans = new HashMap<>();
649 beans.put("bean1", externalAppsRestfulVersionController);
650 Mockito.when(context.getBeansWithAnnotation(ApiVersion.class)).thenReturn(beans);
651 PowerMockito.mockStatic(AopUtils.class);
652 Mockito.when(AopUtils.isAopProxy(Matchers.anyObject())).thenReturn(false);
653 Mockito.when(mockedRequest.getMethod()).thenReturn("GET");
654 assertNull(auxApiRequestMapperController.getFunctionalMenuItemsForUser(mockedRequest, mockedResponse));