gerrit.onap Code Review - portal.git/blob

   1 /*-
   2  * ============LICENSE_START==========================================
   3  * ONAP Portal
   4  * ===================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ===================================================================
   7  *
   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
  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  * 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
  25  *
  26  *             https://creativecommons.org/licenses/by/4.0/
  27  *
  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.
  33  *
  34  * ============LICENSE_END============================================
  35  *
  36  *
  37  */
  38 package org.onap.portalapp.portal.controller;
  39
  40 import static org.junit.Assert.assertEquals;
  41
  42 import java.util.ArrayList;
  43 import java.util.HashMap;
  44 import java.util.List;
  45 import java.util.Map;
  46
  47 import javax.servlet.http.HttpServletRequest;
  48 import javax.servlet.http.HttpServletResponse;
  49
  50 import org.junit.Before;
  51 import org.junit.Test;
  52 import org.mockito.InjectMocks;
  53 import org.mockito.Mock;
  54 import org.mockito.Mockito;
  55 import org.mockito.MockitoAnnotations;
  56 import org.onap.portalapp.portal.controller.DashboardSearchResultController;
  57 import org.onap.portalapp.portal.core.MockEPUser;
  58 import org.onap.portalapp.portal.domain.EPUser;
  59 import org.onap.portalapp.portal.ecomp.model.PortalRestResponse;
  60 import org.onap.portalapp.portal.ecomp.model.PortalRestStatusEnum;
  61 import org.onap.portalapp.portal.ecomp.model.SearchResultItem;
  62 import org.onap.portalapp.portal.framework.MockitoTestSuite;
  63 import org.onap.portalapp.portal.service.DashboardSearchService;
  64 import org.onap.portalapp.portal.service.DashboardSearchServiceImpl;
  65 import org.onap.portalapp.portal.transport.CommonWidget;
  66 import org.onap.portalapp.portal.transport.CommonWidgetMeta;
  67 import org.onap.portalapp.util.EPUserUtils;
  68
  69 public class DashboardSearchResultControllerTest {
  70
  71         @Mock
  72         DashboardSearchService searchService = new DashboardSearchServiceImpl();
  73
  74         @InjectMocks
  75         DashboardSearchResultController dashboardSearchResultController = new DashboardSearchResultController();
  76
  77         @Before
  78         public void setup() {
  79                 MockitoAnnotations.initMocks(this);
  80         }
  81
  82         MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
  83
  84         HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
  85         HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
  86         NullPointerException nullPointerException = new NullPointerException();
  87
  88         @Mock
  89         EPUserUtils ePUserUtils = new EPUserUtils();
  90
  91         MockEPUser mockUser = new MockEPUser();
  92
  93         @Test
  94         public void getWidgetDataTest() {
  95                 String resourceType = "test";
  96                 PortalRestResponse<CommonWidgetMeta> ecpectedPortalRestResponse = new PortalRestResponse<CommonWidgetMeta>();
  97                 ecpectedPortalRestResponse.setMessage("success");
  98                 ecpectedPortalRestResponse.setResponse(null);
  99                 ecpectedPortalRestResponse.setStatus(PortalRestStatusEnum.OK);
 100                 Mockito.when(searchService.getWidgetData(resourceType)).thenReturn(null);
 101                 PortalRestResponse<CommonWidgetMeta> acutualPoratlRestResponse = dashboardSearchResultController
 102                                 .getWidgetData(mockedRequest, resourceType);
 103                 assertEquals(acutualPoratlRestResponse, ecpectedPortalRestResponse);
 104
 105         }
 106
 107         @Test
 108         public void saveWidgetDataBulkTest() {
 109                 PortalRestResponse<String> ecpectedPortalRestResponse = new PortalRestResponse<String>();
 110                 ecpectedPortalRestResponse.setMessage("success");
 111                 ecpectedPortalRestResponse.setResponse(null);
 112                 ecpectedPortalRestResponse.setStatus(PortalRestStatusEnum.OK);
 113
 114                 CommonWidgetMeta commonWidgetMeta = new CommonWidgetMeta();
 115                 commonWidgetMeta.setCategory("test");
 116
 117                 List<CommonWidget> commonWidgetList = new ArrayList<CommonWidget>();
 118                 CommonWidget commonWidget = new CommonWidget();
 119                 commonWidget.setId((long) 1);
 120                 commonWidget.setCategory("test");
 121                 commonWidget.setHref("test_href");
 122                 commonWidget.setTitle("test_title");
 123                 commonWidget.setContent("test_content");
 124                 commonWidget.setEventDate(null);
 125                 commonWidget.setSortOrder(1);
 126
 127                 commonWidgetList.add(commonWidget);
 128
 129                 commonWidgetMeta.setItems(commonWidgetList);
 130
 131                 Mockito.when(searchService.saveWidgetDataBulk(commonWidgetMeta)).thenReturn(null);
 132
 133                 PortalRestResponse<String> actualPortalRestResponse = dashboardSearchResultController
 134                                 .saveWidgetDataBulk(commonWidgetMeta);
 135                 assertEquals(actualPortalRestResponse, ecpectedPortalRestResponse);
 136         }
 137
 138         @Test
 139         public void saveWidgetDataBulkIfCategoryNullTest() {
 140                 PortalRestResponse<String> ecpectedPortalRestResponse = new PortalRestResponse<String>();
 141                 ecpectedPortalRestResponse.setMessage("java.text.ParseException: Unparseable date: \"1\"");
 142                 ecpectedPortalRestResponse.setResponse(null);
 143                 ecpectedPortalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
 144
 145                 CommonWidgetMeta commonWidgetMeta = new CommonWidgetMeta();
 146                 commonWidgetMeta.setCategory("test");
 147
 148                 List<CommonWidget> commonWidgetList = new ArrayList<CommonWidget>();
 149                 CommonWidget commonWidget = new CommonWidget();
 150                 commonWidget.setId(null);
 151                 commonWidget.setCategory(null);
 152                 commonWidget.setHref(null);
 153                 commonWidget.setTitle(null);
 154                 commonWidget.setContent("test_content");
 155                 commonWidget.setEventDate("1");
 156                 commonWidget.setSortOrder(1);
 157                 commonWidgetList.add(commonWidget);
 158                 commonWidgetMeta.setItems(commonWidgetList);
 159
 160                 Mockito.when(searchService.saveWidgetDataBulk(commonWidgetMeta)).thenReturn(null);
 161
 162                 PortalRestResponse<String> actualPortalRestResponse = dashboardSearchResultController
 163                                 .saveWidgetDataBulk(commonWidgetMeta);
 164                 assertEquals(actualPortalRestResponse, ecpectedPortalRestResponse);
 165         }
 166
 167         @Test
 168         public void saveWidgetDataTest() {
 169                 PortalRestResponse<String> ecpectedPortalRestResponse = new PortalRestResponse<String>();
 170                 ecpectedPortalRestResponse.setMessage("success");
 171                 ecpectedPortalRestResponse.setResponse(null);
 172                 ecpectedPortalRestResponse.setStatus(PortalRestStatusEnum.OK);
 173                 CommonWidget commonWidget = new CommonWidget();
 174                 commonWidget.setId((long) 1);
 175                 commonWidget.setCategory("test");
 176                 commonWidget.setHref("test_href");
 177                 commonWidget.setTitle("test_title");
 178                 commonWidget.setContent("test_content");
 179                 commonWidget.setEventDate(null);
 180                 commonWidget.setSortOrder(1);
 181
 182                 Mockito.when(searchService.saveWidgetData(commonWidget)).thenReturn(null);
 183
 184                 PortalRestResponse<String> actualPortalRestResponse = dashboardSearchResultController
 185                                 .saveWidgetData(commonWidget);
 186                 assertEquals(actualPortalRestResponse, ecpectedPortalRestResponse);
 187
 188         }
 189
 190         @Test
 191         public void saveWidgetDataExceptionTest() {
 192                 PortalRestResponse<String> ecpectedPortalRestResponse = new PortalRestResponse<String>();
 193                 ecpectedPortalRestResponse.setMessage("ERROR");
 194                 ecpectedPortalRestResponse.setResponse("Cateogry cannot be null or empty");
 195                 ecpectedPortalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
 196                 CommonWidget commonWidget = new CommonWidget();
 197                 commonWidget.setId((long) 1);
 198                 commonWidget.setCategory("");
 199                 commonWidget.setHref("test_href");
 200                 commonWidget.setTitle("test_title");
 201                 commonWidget.setContent("test_content");
 202                 commonWidget.setEventDate(null);
 203                 commonWidget.setSortOrder(1);
 204
 205                 Mockito.when(searchService.saveWidgetData(commonWidget)).thenReturn(null);
 206
 207                 PortalRestResponse<String> actualPortalRestResponse = dashboardSearchResultController
 208                                 .saveWidgetData(commonWidget);
 209                 assertEquals(actualPortalRestResponse, ecpectedPortalRestResponse);
 210
 211         }
 212
 213         @Test
 214         public void saveWidgetDataDateErrorTest() {
 215                 PortalRestResponse<String> ecpectedPortalRestResponse = new PortalRestResponse<String>();
 216                 ecpectedPortalRestResponse.setMessage("java.text.ParseException: Unparseable date: \"1\"");
 217                 ecpectedPortalRestResponse.setResponse(null);
 218                 ecpectedPortalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
 219                 CommonWidget commonWidget = new CommonWidget();
 220                 commonWidget.setId((long) 1);
 221                 commonWidget.setCategory("test");
 222                 commonWidget.setHref("test_href");
 223                 commonWidget.setTitle("test_title");
 224                 commonWidget.setContent("test_content");
 225                 commonWidget.setEventDate("1");
 226                 commonWidget.setSortOrder(1);
 227
 228                 Mockito.when(searchService.saveWidgetData(commonWidget)).thenReturn(null);
 229
 230                 PortalRestResponse<String> actualPortalRestResponse = dashboardSearchResultController
 231                                 .saveWidgetData(commonWidget);
 232                 assertEquals(actualPortalRestResponse, ecpectedPortalRestResponse);
 233
 234         }
 235
 236         public void deleteWidgetDataTest() {
 237                 PortalRestResponse<String> ecpectedPortalRestResponse = new PortalRestResponse<String>();
 238                 ecpectedPortalRestResponse.setMessage("success");
 239                 ecpectedPortalRestResponse.setResponse(null);
 240                 ecpectedPortalRestResponse.setStatus(PortalRestStatusEnum.OK);
 241                 CommonWidget commonWidget = new CommonWidget();
 242                 commonWidget.setId((long) 1);
 243                 commonWidget.setCategory("test");
 244                 commonWidget.setHref("test_href");
 245                 commonWidget.setTitle("test_title");
 246                 commonWidget.setContent("test_content");
 247                 commonWidget.setEventDate(null);
 248                 commonWidget.setSortOrder(1);
 249                 Mockito.when(searchService.deleteWidgetData(commonWidget)).thenReturn(null);
 250
 251                 PortalRestResponse<String> actualPortalRestResponse = dashboardSearchResultController
 252                                 .deleteWidgetData(commonWidget);
 253                 System.out.println(actualPortalRestResponse);
 254                 assertEquals(actualPortalRestResponse, ecpectedPortalRestResponse);
 255         }
 256
 257         @Test
 258         public void searchPortalIfUserIsNull() {
 259                 EPUser user = null;
 260                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 261                 String searchString = "test";
 262
 263                 PortalRestResponse<Map<String, List<SearchResultItem>>> expectedResult = new PortalRestResponse<Map<String, List<SearchResultItem>>>();
 264                 expectedResult.setMessage("searchPortal: User object is null? - check logs");
 265                 expectedResult.setResponse(new HashMap<String, List<SearchResultItem>>());
 266                 expectedResult.setStatus(PortalRestStatusEnum.ERROR);
 267                 PortalRestResponse<Map<String, List<SearchResultItem>>> actualResult = dashboardSearchResultController
 268                                 .searchPortal(mockedRequest, searchString);
 269                 assertEquals(expectedResult, actualResult);
 270         }
 271
 272         @Test
 273         public void searchPortalIfSearchStringNullTest() {
 274                 EPUser user = mockUser.mockEPUser();
 275                 ;
 276                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 277                 String searchString = null;
 278
 279                 PortalRestResponse<Map<String, List<SearchResultItem>>> expectedResult = new PortalRestResponse<Map<String, List<SearchResultItem>>>();
 280                 expectedResult.setMessage("searchPortal: String string is null");
 281                 expectedResult.setResponse(new HashMap<String, List<SearchResultItem>>());
 282                 expectedResult.setStatus(PortalRestStatusEnum.ERROR);
 283
 284                 PortalRestResponse<Map<String, List<SearchResultItem>>> actualResult = dashboardSearchResultController
 285                                 .searchPortal(mockedRequest, searchString);
 286                 assertEquals(expectedResult, actualResult);
 287         }
 288
 289         @Test
 290         public void searchPortalIfSearchTest() {
 291                 EPUser user = mockUser.mockEPUser();
 292                 ;
 293                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 294                 String searchString = "test";
 295                 List<SearchResultItem> searchResultItemList = new ArrayList<SearchResultItem>();
 296                 SearchResultItem searchResultItem = new SearchResultItem();
 297
 298                 searchResultItem.setId((long) 1);
 299                 searchResultItem.setCategory("test");
 300                 searchResultItem.setName("test_name");
 301                 searchResultItem.setTarget("test_target");
 302                 searchResultItem.setUuid("test_UUId");
 303                 searchResultItemList.add(searchResultItem);
 304                 Map<String, List<SearchResultItem>> expectedResultMap = new HashMap<String, List<SearchResultItem>>();
 305                 expectedResultMap.put(searchString, searchResultItemList);
 306
 307                 PortalRestResponse<Map<String, List<SearchResultItem>>> expectedResult = new PortalRestResponse<Map<String, List<SearchResultItem>>>();
 308                 expectedResult.setMessage("success");
 309                 expectedResult.setResponse(expectedResultMap);
 310                 expectedResult.setStatus(PortalRestStatusEnum.OK);
 311
 312                 Mockito.when(searchService.searchResults(user.getLoginId(), searchString)).thenReturn(expectedResultMap);
 313                 PortalRestResponse<Map<String, List<SearchResultItem>>> actualResult = dashboardSearchResultController
 314                                 .searchPortal(mockedRequest, searchString);
 315                 assertEquals(expectedResult, actualResult);
 316
 317         }
 318
 319         @Test
 320         public void searchPortalIfSearchExcptionTest() {
 321                 EPUser user = mockUser.mockEPUser();
 322                 ;
 323                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 324                 String searchString = "test";
 325
 326                 PortalRestResponse<Map<String, List<SearchResultItem>>> expectedResult = new PortalRestResponse<Map<String, List<SearchResultItem>>>();
 327                 expectedResult.setMessage("null - check logs.");
 328                 expectedResult.setResponse(new HashMap<String, List<SearchResultItem>>());
 329                 expectedResult.setStatus(PortalRestStatusEnum.ERROR);
 330
 331                 Mockito.when(searchService.searchResults(user.getLoginId(), searchString)).thenThrow(nullPointerException);
 332                 PortalRestResponse<Map<String, List<SearchResultItem>>> actualResult = dashboardSearchResultController
 333                                 .searchPortal(mockedRequest, searchString);
 334                 assertEquals(expectedResult, actualResult);
 335         }
 336
 337         @Test
 338         public void getActiveUsersTest() {
 339                 List<String> expectedActiveUsers = new ArrayList<String>();
 340                 EPUser user = mockUser.mockEPUser();
 341                 ;
 342                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 343                 String userId = user.getOrgUserId();
 344                 Mockito.when(searchService.getRelatedUsers(userId)).thenReturn(expectedActiveUsers);
 345                 List<String> actualOnlineUsers = dashboardSearchResultController.getActiveUsers(mockedRequest);
 346                 assertEquals(expectedActiveUsers, actualOnlineUsers);
 347
 348         }
 349
 350         @Test
 351         public void getActiveUsersExceptionTest() {
 352                 List<String> expectedActiveUsers = new ArrayList<String>();
 353                 EPUser user = mockUser.mockEPUser();
 354                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 355                 String userId = user.getOrgUserId();
 356                 Mockito.when(searchService.getRelatedUsers(userId)).thenThrow(nullPointerException);
 357                 List<String> actualOnlineUsers = dashboardSearchResultController.getActiveUsers(mockedRequest);
 358                 assertEquals(expectedActiveUsers, actualOnlineUsers);
 359
 360         }
 361
 362         @Test
 363         public void activeUsersTest() {
 364                 EPUser user = mockUser.mockEPUser();
 365                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 366                 PortalRestResponse<List<String>> expectedResult = new PortalRestResponse<List<String>>();
 367                 expectedResult.setMessage("success");
 368                 expectedResult.setResponse(new ArrayList<>());
 369                 expectedResult.setStatus(PortalRestStatusEnum.OK);
 370                 PortalRestResponse<List<String>> actualResult = dashboardSearchResultController.activeUsers(mockedRequest);
 371
 372                 assertEquals(actualResult, expectedResult);
 373
 374         }
 375
 376         @Test
 377         public void activeUsersIfUserNullTest() {
 378                 EPUser user = null;
 379                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 380                 PortalRestResponse<List<String>> expectedResult = new PortalRestResponse<List<String>>();
 381                 expectedResult.setMessage("User object is null? - check logs");
 382                 expectedResult.setResponse(new ArrayList<>());
 383                 expectedResult.setStatus(PortalRestStatusEnum.ERROR);
 384                 PortalRestResponse<List<String>> actualResult = dashboardSearchResultController.activeUsers(mockedRequest);
 385                 assertEquals(actualResult, expectedResult);
 386
 387         }
 388
 389         @Test
 390         public void activeUsersExceptionTest() {
 391                 EPUser user = mockUser.mockEPUser();
 392                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 393                 PortalRestResponse<List<String>> expectedResult = new PortalRestResponse<List<String>>();
 394                 expectedResult.setMessage("null - check logs.");
 395                 expectedResult.setResponse(new ArrayList<>());
 396                 expectedResult.setStatus(PortalRestStatusEnum.ERROR);
 397                 Mockito.when(searchService.getRelatedUsers(user.getLoginId())).thenThrow(nullPointerException);
 398                 PortalRestResponse<List<String>> actualResult = dashboardSearchResultController.activeUsers(mockedRequest);
 399                 assertEquals(actualResult, expectedResult);
 400
 401         }
 402
 403 }