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

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