ecomp-portal-BE-common/src/test/java/org/openecomp/portalapp/portal/controller/DashboardControllerTest.java

   1 package org.openecomp.portalapp.portal.controller;
   2
   3 import static org.junit.Assert.assertEquals;
   4
   5 import java.io.IOException;
   6 import java.util.ArrayList;
   7 import java.util.List;
   8 import java.util.Map;
   9
  10 import javax.servlet.http.HttpServletRequest;
  11 import javax.servlet.http.HttpServletResponse;
  12
  13 import org.junit.Before;
  14 import org.junit.Test;
  15 import org.junit.runner.RunWith;
  16 import org.mockito.InjectMocks;
  17 import org.mockito.Mock;
  18 import org.mockito.Mockito;
  19 import org.mockito.MockitoAnnotations;
  20 import org.openecomp.portalapp.portal.framework.MockitoTestSuite;
  21 import org.openecomp.portalapp.portal.controller.DashboardController;
  22 import org.openecomp.portalapp.portal.core.MockEPUser;
  23 import org.openecomp.portalapp.portal.domain.EPUser;
  24 import org.openecomp.portalapp.portal.ecomp.model.PortalRestResponse;
  25 import org.openecomp.portalapp.portal.ecomp.model.PortalRestStatusEnum;
  26 import org.openecomp.portalapp.portal.service.DashboardSearchService;
  27 import org.openecomp.portalapp.portal.service.DashboardSearchServiceImpl;
  28 import org.openecomp.portalapp.portal.transport.CommonWidget;
  29 import org.openecomp.portalapp.portal.transport.CommonWidgetMeta;
  30 import org.openecomp.portalapp.portal.utils.EPCommonSystemProperties;
  31 import org.openecomp.portalapp.util.EPUserUtils;
  32 import org.openecomp.portalsdk.core.domain.support.CollaborateList;
  33 import org.openecomp.portalsdk.core.util.SystemProperties;
  34 import org.powermock.api.mockito.PowerMockito;
  35 import org.powermock.core.classloader.annotations.PrepareForTest;
  36 import org.powermock.modules.junit4.PowerMockRunner;
  37
  38
  39 @RunWith(PowerMockRunner.class)
  40 @PrepareForTest({EPUserUtils.class, CollaborateList.class, SystemProperties.class, EPCommonSystemProperties.class})
  41 public class DashboardControllerTest {
  42
  43         @Mock
  44         DashboardSearchService searchService = new DashboardSearchServiceImpl();
  45
  46         @InjectMocks
  47         DashboardController dashboardController = new DashboardController();
  48
  49         @Before
  50         public void setup() {
  51                 MockitoAnnotations.initMocks(this);
  52         }
  53
  54         MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
  55
  56         HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
  57         HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
  58
  59         NullPointerException nullPointerException = new NullPointerException();
  60
  61         MockEPUser mockUser = new MockEPUser();
  62
  63         public CommonWidgetMeta mockCommonWidgetMeta() {
  64                 CommonWidgetMeta commonWidgetMeta= new CommonWidgetMeta();
  65                 List<CommonWidget> widgetList = new ArrayList<>();
  66                 CommonWidget commonWidget = new CommonWidget();
  67                 commonWidget.setId((long) 1);
  68                 commonWidget.setCategory("test");
  69                 commonWidget.setHref("testhref");
  70                 commonWidget.setTitle("testTitle");
  71             commonWidget.setContent("testcontent");
  72             commonWidget.setEventDate("testDate");
  73             commonWidget.setSortOrder(1);
  74                 widgetList.add(commonWidget);
  75                 commonWidgetMeta.setItems(widgetList);
  76
  77                 return commonWidgetMeta;
  78         }
  79
  80         public CommonWidget mockCommonWidget() {
  81
  82                 CommonWidget commonWidget = new CommonWidget();
  83                 commonWidget.setId((long) 1);
  84                 commonWidget.setCategory("test");
  85                 commonWidget.setHref("testhref");
  86                 commonWidget.setTitle("testTitle");
  87             commonWidget.setContent("testcontent");
  88             commonWidget.setEventDate("testDate");
  89             commonWidget.setSortOrder(1);
  90
  91             return commonWidget;
  92         }
  93
  94
  95         @Test
  96         public void getWidgetDataTest() throws IOException {
  97
  98                 String resourceType = null;
  99                 PortalRestResponse<CommonWidgetMeta> expectedData = new PortalRestResponse<CommonWidgetMeta>();
 100                 expectedData.setStatus(PortalRestStatusEnum.ERROR);
 101                 expectedData.setMessage("Unexpected resource type null");
 102                 expectedData.setResponse(null);
 103
 104                 PortalRestResponse<CommonWidgetMeta> actualResponse =   dashboardController.getWidgetData(mockedRequest, resourceType);
 105                 assertEquals(expectedData,actualResponse);
 106         }
 107
 108         @Test
 109         public void getWidgetDataWithValidResourceTest() throws IOException {
 110                 String resourceType = "EVENTS";
 111                 CommonWidgetMeta commonWidgetMeta= mockCommonWidgetMeta();
 112                 commonWidgetMeta.setCategory(null);
 113
 114                 Mockito.when(searchService.getWidgetData(resourceType)).thenReturn(commonWidgetMeta);
 115                 PortalRestResponse<CommonWidgetMeta> expectedData = new PortalRestResponse<CommonWidgetMeta>();
 116                 expectedData.setStatus(PortalRestStatusEnum.OK);
 117                 expectedData.setMessage("success");
 118                 expectedData.setResponse(commonWidgetMeta);
 119
 120                 PortalRestResponse<CommonWidgetMeta> actualResponse = dashboardController.getWidgetData(mockedRequest, resourceType);
 121                 System.out.println(actualResponse);
 122                 assertEquals(expectedData,actualResponse);
 123         }
 124
 125         @Test
 126         public void saveWidgetDataBulkNullTest() throws IOException {
 127                 CommonWidgetMeta commonWidgetMeta= mockCommonWidgetMeta();
 128                 commonWidgetMeta.setCategory(null);
 129
 130                 PortalRestResponse<String> expectedData = new PortalRestResponse<String>();
 131                 expectedData.setStatus(PortalRestStatusEnum.ERROR);
 132                 expectedData.setMessage("ERROR");
 133                 expectedData.setResponse("Category cannot be null or empty");
 134
 135                 PortalRestResponse<String> actualResponse = dashboardController.saveWidgetDataBulk(commonWidgetMeta);
 136                 assertEquals(expectedData,actualResponse);
 137         }
 138
 139         @Test
 140         public void saveWidgetUnexpectedDataBulkTest() throws IOException {
 141                 CommonWidgetMeta commonWidgetMeta= mockCommonWidgetMeta();
 142                 commonWidgetMeta.setCategory("Unexpected Data");
 143
 144                 PortalRestResponse<String> expectedData = new PortalRestResponse<String>();
 145                 expectedData.setStatus(PortalRestStatusEnum.ERROR);
 146                 expectedData.setMessage("Unexpected resource type Unexpected Data");
 147                 expectedData.setResponse(null);
 148
 149                 PortalRestResponse<String> actualResponse = dashboardController.saveWidgetDataBulk(commonWidgetMeta);
 150                 assertEquals(expectedData,actualResponse);
 151
 152         }
 153
 154         @Test
 155         public void saveWidgetInvalidDataBulkTest() throws IOException {
 156                 CommonWidgetMeta commonWidgetMeta= mockCommonWidgetMeta();
 157                 commonWidgetMeta.setCategory("EVENTS");
 158
 159                 PortalRestResponse<String> expectedData = new PortalRestResponse<String>();
 160                 expectedData.setStatus(PortalRestStatusEnum.ERROR);
 161                 expectedData.setMessage("Invalid category: test");
 162                 expectedData.setResponse(null);
 163
 164                 PortalRestResponse<String> actualResponse = dashboardController.saveWidgetDataBulk(commonWidgetMeta);
 165                 assertEquals(expectedData,actualResponse);
 166         }
 167
 168         @Test
 169         public void saveWidgetDataBulkTest() throws IOException {
 170
 171                 List<CommonWidget> widgetList = new ArrayList<>();
 172                 CommonWidget commonWidget = new CommonWidget("EVENTS", "http://test.com", "testTitle", "testcontent", "2017-07-01", 1);
 173                 widgetList.add(commonWidget);
 174                 CommonWidgetMeta commonWidgetMeta= new CommonWidgetMeta("EVENTS", widgetList);
 175
 176
 177
 178         /*      commonWidgetMeta.setItems(widgetList);
 179
 180                 commonWidgetMeta.setCategory("EVENTS");*/
 181
 182                 PortalRestResponse<String> expectedData = new PortalRestResponse<String>();
 183                 expectedData.setStatus(PortalRestStatusEnum.OK);
 184                 expectedData.setMessage("success");
 185                 expectedData.setResponse("success");
 186
 187                 Mockito.when(searchService.saveWidgetDataBulk(commonWidgetMeta)).thenReturn("success");
 188
 189                 PortalRestResponse<String> actualResponse = dashboardController.saveWidgetDataBulk(commonWidgetMeta);
 190                 assertEquals(expectedData,actualResponse);
 191         }
 192
 193         @Test
 194         public void saveWidgetDataNullTest() throws IOException {
 195
 196                 CommonWidget commonWidget = mockCommonWidget();
 197                 commonWidget.setId((long)1);
 198                 commonWidget.setContent("test");
 199                 commonWidget.setCategory(null);
 200                 PortalRestResponse<String> expectedData = new PortalRestResponse<String>();
 201                 expectedData.setStatus(PortalRestStatusEnum.ERROR);
 202                 expectedData.setMessage("ERROR");
 203                 expectedData.setResponse("Category cannot be null or empty");
 204
 205                 PortalRestResponse<String> actualResponse = dashboardController.saveWidgetData(commonWidget);
 206                 assertEquals(expectedData,actualResponse);
 207
 208         }
 209
 210         @Test
 211         public void saveWidgetDataErrorTest() throws IOException {
 212
 213                 CommonWidget commonWidget = mockCommonWidget();
 214                 PortalRestResponse<String> expectedData = new PortalRestResponse<String>();
 215                 expectedData.setStatus(PortalRestStatusEnum.ERROR);
 216                 expectedData.setMessage("Invalid category: test");
 217                 expectedData.setResponse(null);
 218
 219                 PortalRestResponse<String> actualResponse = dashboardController.saveWidgetData(commonWidget);
 220                 assertEquals(expectedData,actualResponse);
 221         }
 222
 223         @Test
 224         public void saveWidgetDataTest() throws IOException {
 225
 226                 CommonWidgetMeta commonWidgetMeta= new CommonWidgetMeta();
 227                 List<CommonWidget> widgetList = new ArrayList<>();
 228                 CommonWidget commonWidget = new CommonWidget();
 229                 commonWidget.setId((long) 1);
 230                 commonWidget.setCategory("EVENTS");
 231                 commonWidget.setHref("http://test.com");
 232                 commonWidget.setTitle("testTitle");
 233             commonWidget.setContent("testcontent");
 234             commonWidget.setEventDate("2017-07-01");
 235             commonWidget.setSortOrder(1);
 236                 widgetList.add(commonWidget);
 237                 commonWidgetMeta.setItems(widgetList);
 238
 239                 commonWidgetMeta.setCategory("EVENTS");
 240
 241                 PortalRestResponse<String> expectedData = new PortalRestResponse<String>();
 242                 expectedData.setStatus(PortalRestStatusEnum.OK);
 243                 expectedData.setMessage("success");
 244                 expectedData.setResponse("success");
 245
 246                 Mockito.when(searchService.saveWidgetData(commonWidget)).thenReturn("success");
 247
 248                 PortalRestResponse<String> actualResponse = dashboardController.saveWidgetData(commonWidget);
 249                 assertEquals(expectedData,actualResponse);
 250
 251         }
 252
 253         @Test
 254         public void deleteWidgetDataTest() throws IOException {
 255
 256                 CommonWidget commonWidget = mockCommonWidget();
 257
 258                 PortalRestResponse<String> expectedData = new PortalRestResponse<String>();
 259                 expectedData.setStatus(PortalRestStatusEnum.OK);
 260                 expectedData.setMessage("success");
 261                 expectedData.setResponse(null);
 262
 263                 Mockito.when(searchService.saveWidgetData(commonWidget)).thenReturn("success");
 264
 265                 PortalRestResponse<String> actualResponse = dashboardController.deleteWidgetData(commonWidget);
 266                 assertEquals(expectedData,actualResponse);
 267
 268         }
 269
 270         @Test
 271         public void getActiveUsersTest(){
 272                 List<String> activeUsers = new ArrayList<>();
 273                 List<String> expectedUsersList = new ArrayList<>();
 274                 EPUser user = mockUser.mockEPUser();
 275                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 276                 String userId = user.getOrgUserId();
 277                 Mockito.when(searchService.getRelatedUsers(userId)).thenReturn(activeUsers);
 278                 expectedUsersList=      dashboardController.getActiveUsers(mockedRequest);
 279                 assertEquals(expectedUsersList, activeUsers);
 280         }
 281
 282
 283         @Test
 284         public void getActiveUsersExceptionTest(){
 285                 List<String> activeUsers = new ArrayList<>();
 286                 List<String> expectedUsersList = new ArrayList<>();
 287                 EPUser user = mockUser.mockEPUser();
 288                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 289                 String userId = user.getOrgUserId();
 290                 Mockito.when(searchService.getRelatedUsers(userId)).thenThrow(nullPointerException);
 291                 expectedUsersList = dashboardController.getActiveUsers(mockedRequest);
 292                 assertEquals(expectedUsersList, activeUsers);
 293         }
 294
 295         @Test
 296         public void getOnlineUserUpdateRateTest(){
 297                 PortalRestResponse<String> expectedData = new PortalRestResponse<String>();
 298                 expectedData.setStatus(PortalRestStatusEnum.OK);
 299                 expectedData.setMessage("success");
 300                 expectedData.setResponse("{onlineUserUpdateRate=1400000, onlineUserUpdateDuration=1400000}");
 301
 302                 PowerMockito.mockStatic(SystemProperties.class);
 303                 PowerMockito.mockStatic(EPCommonSystemProperties.class);
 304                 Mockito.when(SystemProperties.getProperty(EPCommonSystemProperties.ONLINE_USER_UPDATE_RATE)).thenReturn("1400");
 305                 Mockito.when(SystemProperties.getProperty(EPCommonSystemProperties.ONLINE_USER_UPDATE_DURATION)).thenReturn("1400");
 306
 307                 PortalRestResponse<Map<String, String>> actualResponse = dashboardController.getOnlineUserUpdateRate(mockedRequest);
 308                 assertEquals(expectedData.getStatus(),actualResponse.getStatus());
 309         }
 310
 311         @Test
 312         public void getOnlineUserUpdateRateExceptionTest(){
 313                 PortalRestResponse<String> expectedData = new PortalRestResponse<String>();
 314                 expectedData.setStatus(PortalRestStatusEnum.ERROR);
 315                 expectedData.setMessage("java.lang.NullPointerException");
 316                 expectedData.setResponse(null);
 317
 318                 PowerMockito.mockStatic(SystemProperties.class);
 319                 PowerMockito.mockStatic(EPCommonSystemProperties.class);
 320                 Mockito.when(SystemProperties.getProperty(EPCommonSystemProperties.ONLINE_USER_UPDATE_RATE)).thenThrow(nullPointerException);
 321                 Mockito.when(SystemProperties.getProperty(EPCommonSystemProperties.ONLINE_USER_UPDATE_DURATION)).thenThrow(nullPointerException);
 322
 323                 PortalRestResponse<Map<String, String>> actualResponse = dashboardController.getOnlineUserUpdateRate(mockedRequest);
 324                 assertEquals(expectedData,actualResponse);
 325         }
 326
 327         @Test
 328         public void getWindowWidthThresholdForRightMenuTest(){
 329                 PortalRestResponse<String> expectedData = new PortalRestResponse<String>();
 330                 expectedData.setStatus(PortalRestStatusEnum.OK);
 331                 expectedData.setMessage("success");
 332                 expectedData.setResponse("{windowWidth=1400}");
 333
 334                 PowerMockito.mockStatic(SystemProperties.class);
 335                 PowerMockito.mockStatic(EPCommonSystemProperties.class);
 336                 Mockito.when(SystemProperties.getProperty(EPCommonSystemProperties.WINDOW_WIDTH_THRESHOLD_RIGHT_MENU)).thenReturn("1400");
 337
 338                 PortalRestResponse<Map<String, String>> actualResponse = dashboardController.getWindowWidthThresholdForRightMenu(mockedRequest);
 339                 assertEquals(expectedData.getStatus(),actualResponse.getStatus());
 340         }
 341
 342         @Test
 343         public void getWindowWidthThresholdForRightMenuExceptionTest(){
 344                 PortalRestResponse<String> expectedData = new PortalRestResponse<String>();
 345                 expectedData.setStatus(PortalRestStatusEnum.ERROR);
 346                 expectedData.setMessage("java.lang.NullPointerException");
 347                 expectedData.setResponse(null);
 348
 349                 PowerMockito.mockStatic(SystemProperties.class);
 350                 PowerMockito.mockStatic(EPCommonSystemProperties.class);
 351                 Mockito.when(SystemProperties.getProperty(EPCommonSystemProperties.WINDOW_WIDTH_THRESHOLD_RIGHT_MENU)).thenThrow(nullPointerException);
 352
 353                 PortalRestResponse<Map<String, String>> actualResponse = dashboardController.getWindowWidthThresholdForRightMenu(mockedRequest);
 354                 assertEquals(expectedData,actualResponse);
 355         }
 356
 357         @Test
 358         public void getWindowWidthThresholdForLeftMenuTest(){
 359                 PortalRestResponse<String> expectedData = new PortalRestResponse<String>();
 360                 expectedData.setStatus(PortalRestStatusEnum.OK);
 361                 expectedData.setMessage("success");
 362                 expectedData.setResponse("{windowWidth=1400}");
 363
 364                 PowerMockito.mockStatic(SystemProperties.class);
 365                 PowerMockito.mockStatic(EPCommonSystemProperties.class);
 366                 Mockito.when(SystemProperties.getProperty(EPCommonSystemProperties.WINDOW_WIDTH_THRESHOLD_LEFT_MENU)).thenReturn("1400");
 367
 368                 PortalRestResponse<Map<String, String>> actualResponse = dashboardController.getWindowWidthThresholdForLeftMenu(mockedRequest);
 369                 assertEquals(expectedData.getStatus(),actualResponse.getStatus());
 370         }
 371
 372         @Test
 373         public void getWindowWidthThresholdForLeftMenuExceptionTest(){
 374                 PortalRestResponse<String> expectedData = new PortalRestResponse<String>();
 375                 expectedData.setStatus(PortalRestStatusEnum.ERROR);
 376                 expectedData.setMessage("java.lang.NullPointerException");
 377                 expectedData.setResponse(null);
 378
 379                 PowerMockito.mockStatic(SystemProperties.class);
 380                 PowerMockito.mockStatic(EPCommonSystemProperties.class);
 381                 Mockito.when(SystemProperties.getProperty(EPCommonSystemProperties.WINDOW_WIDTH_THRESHOLD_LEFT_MENU)).thenThrow(nullPointerException);
 382
 383                 PortalRestResponse<Map<String, String>> actualResponse = dashboardController.getWindowWidthThresholdForLeftMenu(mockedRequest);
 384                 assertEquals(expectedData,actualResponse);
 385         }
 386
 387         @Test
 388         public void getActiveUsersNullTest(){
 389                 PortalRestResponse<List<String>> expectedData = new PortalRestResponse<List<String>>();
 390                 expectedData.setStatus(PortalRestStatusEnum.ERROR);
 391                 expectedData.setMessage("User object is null? - check logs");
 392                 expectedData.setResponse(new ArrayList<>());
 393
 394                 PortalRestResponse<List<String>> actualResponse = dashboardController.activeUsers(mockedRequest);
 395                 assertEquals(expectedData,actualResponse);
 396         }
 397
 398         @Test
 399         public void activeUsersTest(){
 400                 EPUser user = mockUser.mockEPUser();
 401                 PortalRestResponse<List<String>> expectedData = new PortalRestResponse<List<String>>();
 402                 expectedData.setStatus(PortalRestStatusEnum.OK);
 403                 expectedData.setMessage("success");
 404                 expectedData.setResponse(new ArrayList<>());
 405                 PowerMockito.mockStatic(EPUserUtils.class);
 406                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 407                 PortalRestResponse<List<String>> actualResponse = dashboardController.activeUsers(mockedRequest);
 408                 assertEquals(expectedData,actualResponse);
 409         }
 410
 411 //      @Test
 412 //      public void activeUsersExceptionTest(){
 413 //              EPUser user = mockUser.mockEPUser();
 414 //              user.setLoginId("test");
 415 //              String loginId = "abc";
 416 //              PortalRestResponse<List<String>> expectedData = new PortalRestResponse<List<String>>();
 417 //              expectedData.setStatus(PortalRestStatusEnum.ERROR);
 418 //              expectedData.setMessage("java.lang.NullPointerException");
 419 //              expectedData.setResponse(null);
 420 //
 421 ////            PowerMockito.mockStatic(EPUserUtils.class);
 422 //              Mockito.when(searchService.getRelatedUsers(user.getLoginId(user.getLoginId()))).thenReturn(nullPointerException);
 423 //              PortalRestResponse<List<String>> actualResponse = dashboardController.activeUsers(mockedRequest);
 424 //              System.out.println(actualResponse);
 425 //              //assertEquals(expectedData,actualResponse);
 426 //      }
 427 }