ecomp-portal-BE-os/src/test/java/org/onap/portalapp/portal/controller/DashboardSearchResultControllerTest.java

   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  * ECOMP is a trademark and service mark of AT&T Intellectual Property.
  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.domain.EPUser;
  58 import org.onap.portalapp.portal.ecomp.model.PortalRestResponse;
  59 import org.onap.portalapp.portal.ecomp.model.PortalRestStatusEnum;
  60 import org.onap.portalapp.portal.ecomp.model.SearchResultItem;
  61 import org.onap.portalapp.portal.framework.MockEPUser;
  62 import org.onap.portalapp.portal.framework.MockitoTestSuite;
  63 import org.onap.portalapp.portal.service.DashboardSearchService;
  64 import org.onap.portalapp.portal.transport.CommonWidget;
  65 import org.onap.portalapp.portal.transport.CommonWidgetMeta;
  66 import org.onap.portalapp.util.EPUserUtils;
  67
  68 public class DashboardSearchResultControllerTest {
  69
  70         @Mock
  71         DashboardSearchService searchService;
  72
  73         @Before
  74         public void setup() {
  75                 MockitoAnnotations.initMocks(this);
  76         }
  77
  78         @InjectMocks
  79         DashboardSearchResultController dashboardSearchResultController = new DashboardSearchResultController();
  80
  81         MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
  82
  83         HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
  84         HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
  85         NullPointerException nullPointerException = new NullPointerException();
  86         MockEPUser mockUser = new MockEPUser();
  87
  88         @Test
  89         public void getWidgetDataTest() {
  90                 PortalRestResponse<CommonWidgetMeta> ecpectedPortalRestResponse = new PortalRestResponse<CommonWidgetMeta>();
  91                 ecpectedPortalRestResponse.setMessage("success");
  92                 ecpectedPortalRestResponse.setResponse(new CommonWidgetMeta());
  93                 ecpectedPortalRestResponse.setStatus(PortalRestStatusEnum.OK);
  94                 CommonWidgetMeta commonWidgetMeta = new CommonWidgetMeta();
  95                 Mockito.when(searchService.getWidgetData("test")).thenReturn(commonWidgetMeta);
  96                 PortalRestResponse<CommonWidgetMeta> actualPortalRestResponse = dashboardSearchResultController
  97                                 .getWidgetData(mockedRequest, "test");
  98                 assertEquals(ecpectedPortalRestResponse.getStatus(), actualPortalRestResponse.getStatus());
  99         }
 100
 101         @Test
 102         public void saveWidgetDataBulkIfCatrgoryNullTest() {
 103                 PortalRestResponse<String> ecpectedPortalRestResponse = new PortalRestResponse<String>();
 104                 ecpectedPortalRestResponse.setMessage("ERROR");
 105                 ecpectedPortalRestResponse.setResponse("Category cannot be null or empty");
 106                 ecpectedPortalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
 107                 CommonWidgetMeta commonWidgetMeta = new CommonWidgetMeta();
 108                 commonWidgetMeta.setCategory(null);
 109                 PortalRestResponse<String> actualPortalRestResponse = dashboardSearchResultController
 110                                 .saveWidgetDataBulk(commonWidgetMeta);
 111                 assertEquals(ecpectedPortalRestResponse, actualPortalRestResponse);
 112         }
 113
 114         @Test
 115         public void saveWidgetDataBulkTest() {
 116                 PortalRestResponse<String> ecpectedPortalRestResponse = new PortalRestResponse<String>();
 117                 ecpectedPortalRestResponse.setMessage("success");
 118                 ecpectedPortalRestResponse.setResponse(null);
 119                 ecpectedPortalRestResponse.setStatus(PortalRestStatusEnum.OK);
 120                 CommonWidgetMeta commonWidgetMeta = new CommonWidgetMeta();
 121                 commonWidgetMeta.setCategory("test");
 122                 List<CommonWidget> items = new ArrayList<>();
 123
 124                 CommonWidget commonWidget = new CommonWidget();
 125                 commonWidget.setId((long) 1);
 126                 commonWidget.setEventDate("2017-06-06");
 127                 items.add(commonWidget);
 128                 commonWidgetMeta.setItems(items);
 129                 PortalRestResponse<String> actualPortalRestResponse = dashboardSearchResultController
 130                                 .saveWidgetDataBulk(commonWidgetMeta);
 131                 assertEquals(ecpectedPortalRestResponse, actualPortalRestResponse);
 132         }
 133
 134         @Test
 135         public void saveWidgetDataBulkExceptionTest() {
 136                 PortalRestResponse<String> ecpectedPortalRestResponse = new PortalRestResponse<String>();
 137                 ecpectedPortalRestResponse.setMessage("java.text.ParseException: Unparseable date: \"date\"");
 138                 ecpectedPortalRestResponse.setResponse(null);
 139                 ecpectedPortalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
 140                 CommonWidgetMeta commonWidgetMeta = new CommonWidgetMeta();
 141                 commonWidgetMeta.setCategory("test");
 142                 List<CommonWidget> items = new ArrayList<>();
 143
 144                 CommonWidget commonWidget = new CommonWidget();
 145                 commonWidget.setId((long) 1);
 146                 commonWidget.setEventDate("date");
 147                 items.add(commonWidget);
 148                 commonWidgetMeta.setItems(items);
 149                 PortalRestResponse<String> actualPortalRestResponse = dashboardSearchResultController
 150                                 .saveWidgetDataBulk(commonWidgetMeta);
 151                 assertEquals(ecpectedPortalRestResponse, actualPortalRestResponse);
 152         }
 153
 154         @Test
 155         public void saveWidgetDataIfCatagoryNullTest() {
 156                 PortalRestResponse<String> ecpectedPortalRestResponse = new PortalRestResponse<String>();
 157                 ecpectedPortalRestResponse.setMessage("ERROR");
 158                 ecpectedPortalRestResponse.setResponse("Cateogry cannot be null or empty");
 159                 ecpectedPortalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
 160                 CommonWidget commonWidget = new CommonWidget();
 161                 commonWidget.setCategory(null);
 162                 PortalRestResponse<String> actualPortalRestResponse = dashboardSearchResultController
 163                                 .saveWidgetData(commonWidget);
 164                 assertEquals(ecpectedPortalRestResponse, actualPortalRestResponse);
 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.setCategory("test");
 175                 commonWidget.setId((long) 1);
 176                 commonWidget.setEventDate("2017-06-06");
 177                 PortalRestResponse<String> actualPortalRestResponse = dashboardSearchResultController
 178                                 .saveWidgetData(commonWidget);
 179                 assertEquals(ecpectedPortalRestResponse, actualPortalRestResponse);
 180         }
 181
 182         @Test
 183         public void saveWidgetDataExceptionTest() {
 184                 PortalRestResponse<String> ecpectedPortalRestResponse = new PortalRestResponse<String>();
 185                 ecpectedPortalRestResponse.setMessage("java.text.ParseException: Unparseable date: \"date\"");
 186                 ecpectedPortalRestResponse.setResponse(null);
 187                 ecpectedPortalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
 188                 CommonWidget commonWidget = new CommonWidget();
 189                 commonWidget.setCategory("test");
 190                 commonWidget.setId((long) 1);
 191                 commonWidget.setEventDate("date");
 192                 PortalRestResponse<String> actualPortalRestResponse = dashboardSearchResultController
 193                                 .saveWidgetData(commonWidget);
 194                 assertEquals(ecpectedPortalRestResponse, actualPortalRestResponse);
 195         }
 196
 197         @Test
 198         public void deleteWidgetDataTest()
 199         {
 200                 PortalRestResponse<String> ecpectedPortalRestResponse = new PortalRestResponse<String>();
 201                 ecpectedPortalRestResponse.setMessage("success");
 202                 ecpectedPortalRestResponse.setResponse(null);
 203                 ecpectedPortalRestResponse.setStatus(PortalRestStatusEnum.OK);
 204                 CommonWidget commonWidget = new CommonWidget();
 205                 Mockito.when(searchService.deleteWidgetData(commonWidget)).thenReturn("test");
 206                 PortalRestResponse<String> actualPortalRestResponse = dashboardSearchResultController
 207                                 .deleteWidgetData(commonWidget);
 208                 assertEquals(ecpectedPortalRestResponse.getStatus(), actualPortalRestResponse.getStatus());
 209         }
 210
 211         @Test
 212         public void searchPortalIfUserIsTest()
 213         {
 214                 EPUser user = null;
 215                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 216                 String searchString = "test";
 217                 PortalRestResponse<Map<String, List<SearchResultItem>>> expectedResult = new PortalRestResponse<Map<String, List<SearchResultItem>>>();
 218                 expectedResult.setMessage("searchPortal: User object is null? - check logs");
 219                 expectedResult.setResponse(new HashMap<String, List<SearchResultItem>>());
 220                 expectedResult.setStatus(PortalRestStatusEnum.ERROR);
 221                 PortalRestResponse<Map<String, List<SearchResultItem>>> actualResult = dashboardSearchResultController
 222                                 .searchPortal(mockedRequest, searchString);
 223                 System.out.println(actualResult);
 224
 225                 assertEquals(expectedResult, actualResult);
 226         }
 227
 228
 229         @Test
 230         public void getActiveUsersTest() {
 231                 List<String> expectedActiveUsers = new ArrayList<String>();
 232                 EPUser user = mockUser.mockEPUser();
 233                 ;
 234                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 235                 String userId = user.getOrgUserId();
 236                 Mockito.when(searchService.getRelatedUsers(userId)).thenReturn(expectedActiveUsers);
 237                 List<String> actualOnlineUsers = dashboardSearchResultController.getActiveUsers(mockedRequest);
 238                 assertEquals(expectedActiveUsers, actualOnlineUsers);
 239
 240         }
 241
 242         @Test
 243         public void getActiveUsersExceptionTest() {
 244                 List<String> expectedActiveUsers = new ArrayList<String>();
 245                 EPUser user = mockUser.mockEPUser();
 246                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 247                 String userId = user.getOrgUserId();
 248                 Mockito.when(searchService.getRelatedUsers(userId)).thenThrow(nullPointerException);
 249                 List<String> actualOnlineUsers = dashboardSearchResultController.getActiveUsers(mockedRequest);
 250                 assertEquals(expectedActiveUsers, actualOnlineUsers);
 251
 252         }
 253
 254         @Test
 255         public void activeUsersTest() {
 256                 EPUser user = mockUser.mockEPUser();
 257                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 258                 PortalRestResponse<List<String>> expectedResult = new PortalRestResponse<List<String>>();
 259                 expectedResult.setMessage("success");
 260                 expectedResult.setResponse(new ArrayList<>());
 261                 expectedResult.setStatus(PortalRestStatusEnum.OK);
 262                 PortalRestResponse<List<String>> actualResult = dashboardSearchResultController.activeUsers(mockedRequest);
 263
 264                 assertEquals(actualResult, expectedResult);
 265
 266         }
 267
 268         @Test
 269         public void activeUsersIfUserNullTest() {
 270                 EPUser user = null;
 271                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 272                 PortalRestResponse<List<String>> expectedResult = new PortalRestResponse<List<String>>();
 273                 expectedResult.setMessage("User object is null? - check logs");
 274                 expectedResult.setResponse(new ArrayList<>());
 275                 expectedResult.setStatus(PortalRestStatusEnum.ERROR);
 276                 PortalRestResponse<List<String>> actualResult = dashboardSearchResultController.activeUsers(mockedRequest);
 277                 assertEquals(actualResult, expectedResult);
 278
 279         }
 280
 281         @Test
 282         public void activeUsersExceptionTest() {
 283                 EPUser user = mockUser.mockEPUser();
 284                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 285                 PortalRestResponse<List<String>> expectedResult = new PortalRestResponse<List<String>>();
 286                 expectedResult.setMessage("null - check logs.");
 287                 expectedResult.setResponse(new ArrayList<>());
 288                 expectedResult.setStatus(PortalRestStatusEnum.ERROR);
 289                 Mockito.when(searchService.getRelatedUsers(user.getLoginId())).thenThrow(nullPointerException);
 290                 PortalRestResponse<List<String>> actualResult = dashboardSearchResultController.activeUsers(mockedRequest);
 291                 assertEquals(actualResult, expectedResult);
 292
 293         }
 294
 295         @Test
 296         public void searchPortalIfSearchStringNullTest() {
 297                 EPUser user = mockUser.mockEPUser();
 298                 ;
 299                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 300                 String searchString = null;
 301
 302                 PortalRestResponse<Map<String, List<SearchResultItem>>> expectedResult = new PortalRestResponse<Map<String, List<SearchResultItem>>>();
 303                 expectedResult.setMessage("searchPortal: String string is null");
 304                 expectedResult.setResponse(new HashMap<String, List<SearchResultItem>>());
 305                 expectedResult.setStatus(PortalRestStatusEnum.ERROR);
 306
 307                 PortalRestResponse<Map<String, List<SearchResultItem>>> actualResult = dashboardSearchResultController
 308                                 .searchPortal(mockedRequest, searchString);
 309                 assertEquals(expectedResult, actualResult);
 310         }
 311
 312         @Test
 313         public void searchPortalIfSearchTest() {
 314                 EPUser user = mockUser.mockEPUser();
 315                 ;
 316                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 317                 String searchString = "test";
 318                 List<SearchResultItem> searchResultItemList = new ArrayList<SearchResultItem>();
 319                 SearchResultItem searchResultItem = new SearchResultItem();
 320
 321                 searchResultItem.setId((long) 1);
 322                 searchResultItem.setCategory("test");
 323                 searchResultItem.setName("test_name");
 324                 searchResultItem.setTarget("test_target");
 325                 searchResultItem.setUuid("test_UUId");
 326                 searchResultItemList.add(searchResultItem);
 327                 Map<String, List<SearchResultItem>> expectedResultMap = new HashMap<String, List<SearchResultItem>>();
 328                 expectedResultMap.put(searchString, searchResultItemList);
 329
 330                 PortalRestResponse<Map<String, List<SearchResultItem>>> expectedResult = new PortalRestResponse<Map<String, List<SearchResultItem>>>();
 331                 expectedResult.setMessage("success");
 332                 expectedResult.setResponse(expectedResultMap);
 333                 expectedResult.setStatus(PortalRestStatusEnum.OK);
 334
 335                 Mockito.when(searchService.searchResults(user.getLoginId(), searchString)).thenReturn(expectedResultMap);
 336                 PortalRestResponse<Map<String, List<SearchResultItem>>> actualResult = dashboardSearchResultController
 337                                 .searchPortal(mockedRequest, searchString);
 338                 assertEquals(expectedResult, actualResult);
 339
 340         }
 341
 342         @Test
 343         public void searchPortalIfSearchExcptionTest() {
 344                 EPUser user = mockUser.mockEPUser();
 345                 ;
 346                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 347                 String searchString = "test";
 348
 349                 PortalRestResponse<Map<String, List<SearchResultItem>>> expectedResult = new PortalRestResponse<Map<String, List<SearchResultItem>>>();
 350                 expectedResult.setMessage("null - check logs.");
 351                 expectedResult.setResponse(new HashMap<String, List<SearchResultItem>>());
 352                 expectedResult.setStatus(PortalRestStatusEnum.ERROR);
 353
 354                 Mockito.when(searchService.searchResults(user.getLoginId(), searchString)).thenThrow(nullPointerException);
 355                 PortalRestResponse<Map<String, List<SearchResultItem>>> actualResult = dashboardSearchResultController
 356                                 .searchPortal(mockedRequest, searchString);
 357                 assertEquals(expectedResult, actualResult);
 358         }
 359
 360 }