gerrit.onap Code Review - portal/sdk.git/blob

   1 /*
   2  * ============LICENSE_START==========================================
   3  * ONAP Portal SDK
   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  *
  37  */
  38 package org.onap.portalsdk.analytics.model.runtime;
  39
  40 import static org.junit.Assert.assertEquals;
  41
  42 import java.io.IOException;
  43 import java.io.OutputStreamWriter;
  44 import java.io.PrintWriter;
  45 import java.io.StringWriter;
  46 import java.sql.ResultSet;
  47 import java.sql.ResultSetMetaData;
  48 import java.util.ArrayList;
  49 import java.util.HashMap;
  50 import java.util.List;
  51 import java.util.Map;
  52 import java.util.Vector;
  53
  54 import javax.servlet.ServletContext;
  55 import javax.servlet.ServletOutputStream;
  56 import javax.servlet.http.HttpServletRequest;
  57 import javax.servlet.http.HttpServletResponse;
  58
  59 import org.junit.Before;
  60 import org.junit.Test;
  61 import org.junit.runner.RunWith;
  62 import org.mockito.InjectMocks;
  63 import org.mockito.Matchers;
  64 import org.mockito.Mock;
  65 import org.mockito.Mockito;
  66 import org.mockito.MockitoAnnotations;
  67 import org.onap.portalsdk.analytics.controller.Action;
  68 import org.onap.portalsdk.analytics.controller.ActionMapping;
  69 import org.onap.portalsdk.analytics.controller.ErrorHandler;
  70 import org.onap.portalsdk.analytics.error.RaptorException;
  71 import org.onap.portalsdk.analytics.model.DataCache;
  72 import org.onap.portalsdk.analytics.model.ReportHandler;
  73 import org.onap.portalsdk.analytics.model.ReportLoader;
  74 import org.onap.portalsdk.analytics.model.base.IdNameValue;
  75 import org.onap.portalsdk.analytics.model.base.ReportWrapper;
  76 import org.onap.portalsdk.analytics.model.definition.ReportDefinition;
  77 import org.onap.portalsdk.analytics.model.definition.SecurityEntry;
  78 import org.onap.portalsdk.analytics.model.definition.wizard.ColumnJSON;
  79 import org.onap.portalsdk.analytics.model.definition.wizard.DefinitionJSON;
  80 import org.onap.portalsdk.analytics.system.AppUtils;
  81 import org.onap.portalsdk.analytics.system.ConnectionUtils;
  82 import org.onap.portalsdk.analytics.system.DbUtils;
  83 import org.onap.portalsdk.analytics.system.Globals;
  84 import org.onap.portalsdk.analytics.system.fusion.web.RaptorControllerAsync;
  85 import org.onap.portalsdk.analytics.util.AppConstants;
  86 import org.onap.portalsdk.analytics.util.DataSet;
  87 import org.onap.portalsdk.analytics.util.Utils;
  88 import org.onap.portalsdk.analytics.util.XSSFilter;
  89 import org.onap.portalsdk.analytics.view.ReportData;
  90 import org.onap.portalsdk.analytics.xmlobj.CustomReportType;
  91 import org.onap.portalsdk.analytics.xmlobj.DataColumnType;
  92 import org.onap.portalsdk.analytics.xmlobj.DataSourceList;
  93 import org.onap.portalsdk.analytics.xmlobj.FormFieldList;
  94 import org.onap.portalsdk.analytics.xmlobj.FormFieldType;
  95 import org.onap.portalsdk.analytics.xmlobj.MockRunTimeReport;
  96 import org.onap.portalsdk.analytics.xmlobj.MockitoTestSuite;
  97 import org.onap.portalsdk.core.domain.User;
  98 import org.onap.portalsdk.core.service.DataAccessService;
  99 import org.onap.portalsdk.core.util.SecurityCodecUtil;
 100 import org.onap.portalsdk.core.web.support.UserUtils;
 101 import org.owasp.esapi.ESAPI;
 102 import org.owasp.esapi.codecs.Codec;
 103 import org.powermock.api.mockito.PowerMockito;
 104 import org.powermock.core.classloader.annotations.PrepareForTest;
 105 import org.powermock.modules.junit4.PowerMockRunner;
 106 import org.powermock.reflect.exceptions.MethodInvocationException;
 107
 108 @RunWith(PowerMockRunner.class)
 109 @PrepareForTest({ AppConstants.class, Globals.class, AppUtils.class, ReportWrapper.class, DataCache.class,
 110                 DbUtils.class, DataSet.class , ReportLoader.class ,ReportRuntime.class, Utils.class, ESAPI.class,
 111                 Codec.class,SecurityCodecUtil.class , ConnectionUtils.class, XSSFilter.class, RaptorControllerAsync.class})
 112 public class RaptorControllerAsyncTest {
 113
 114         @InjectMocks
 115         RaptorControllerAsync raptorControllerAsync = new RaptorControllerAsync();
 116
 117         @Before
 118         public void setup() {
 119                 MockitoAnnotations.initMocks(this);
 120         }
 121
 122         @Mock
 123         DataAccessService dataAccessService;
 124
 125         @Mock
 126         AppConstants appConstants;
 127
 128         @Mock
 129         Globals globals;
 130         @Mock
 131         Action action = new Action("test", "RaptorControllerAsync", "test", "test");
 132         @Mock
 133         ActionMapping actionMapping = new ActionMapping();
 134         @Mock
 135         ReportDefinition reportDefinition ;
 136
 137         @Mock
 138         ReportHandler reportHandler = new ReportHandler();
 139
 140         MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
 141         HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
 142         HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
 143         NullPointerException nullPointerException = new NullPointerException();
 144
 145         MockRunTimeReport mockRunTimeReport = new MockRunTimeReport();
 146
 147         @Test
 148         public void RaptorSearchToDownloadexcel2007Test() throws Exception {
 149                 Mockito.when(mockedRequest.getParameter(AppConstants.RI_ACTION))
 150                                 .thenReturn("report.download.excel2007.session");
 151                 Mockito.when(mockedRequest.getParameter("action")).thenReturn("report.download.excel2007.session");
 152                 User user = new User();
 153                 user.setOrgUserId("test12");
 154                 Mockito.when(UserUtils.getUserSession(mockedRequest)).thenReturn(user);
 155                 ServletContext servletContext = PowerMockito.mock(ServletContext.class);
 156                 Mockito.when(mockedRequest.getSession().getServletContext()).thenReturn(servletContext);
 157                 Mockito.when(mockedRequest.getParameter("parent")).thenReturn("parent_test");
 158                 PowerMockito.mockStatic(Globals.class);
 159                 PowerMockito.mockStatic(AppUtils.class);
 160                 Mockito.when(Globals.isSystemInitialized()).thenReturn(true);
 161                 Mockito.when(AppUtils.getUserID(mockedRequest)).thenReturn("test12");
 162                 ReportRuntime reportRuntime = mockRunTimeReport.mockReportRuntime();
 163                 ReportData reportData = PowerMockito.mock(ReportData.class);
 164                 Mockito.when(mockedRequest.getSession().getAttribute("parent_test" + "_rr")).thenReturn(reportRuntime);
 165                 Mockito.when(mockedRequest.getSession().getAttribute("parent_test" + "_rd")).thenReturn(reportData);
 166                 OutputStreamWriter outputStreamWriter = PowerMockito.mock(OutputStreamWriter.class);
 167                 ServletOutputStream ServletOutputStream = PowerMockito.mock(ServletOutputStream.class);
 168                 Mockito.when(mockedResponse.getOutputStream()).thenReturn(ServletOutputStream);
 169                 Mockito.doNothing().when(reportHandler).createExcel2007FileContent(Matchers.any(OutputStreamWriter.class), Matchers.any(ReportData.class),
 170                                 Matchers.any(ReportRuntime.class), Matchers.any(HttpServletRequest.class), Matchers.any(HttpServletResponse.class), Matchers.any(String.class), Matchers.anyInt());
 171
 172                 reportRuntime = PowerMockito.mock(ReportRuntime.class);
 173            Mockito.when(reportRuntime.getReportDataSQL("test12", 500, mockedRequest)).thenReturn("test");
 174            StringWriter sw = new StringWriter();
 175                 PrintWriter writer = new PrintWriter(sw);
 176                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 177                 Mockito.when(Globals.getGenerateSubsetSql()).thenReturn("test");
 178                 Mockito.when(Globals.getReportSqlOnlyFirstPart()).thenReturn("test");
 179                 raptorControllerAsync.RaptorSearch(mockedRequest, mockedResponse);
 180         }
 181
 182         @Test(expected = java.lang.NullPointerException.class)
 183         public void RaptorSearchNullActionKeyTest() throws Exception {
 184                 User user = new User();
 185                 user.setOrgUserId("test12");
 186                 Mockito.when(UserUtils.getUserSession(mockedRequest)).thenReturn(user);
 187                 ServletContext servletContext = PowerMockito.mock(ServletContext.class);
 188                 Mockito.when(mockedRequest.getSession().getServletContext()).thenReturn(servletContext);
 189                 PowerMockito.mockStatic(Globals.class);
 190                 Mockito.when(Globals.isSystemInitialized()).thenReturn(true);
 191                 Mockito.when(Globals.getRaptorActionMapping()).thenReturn(actionMapping);
 192                 Action action1 = new Action("test",
 193                                 "org.onap.portalsdk.analytics.system.fusion.service.RaptorControllerAsyncTest", "test", "test");
 194                 Mockito.when(actionMapping.getAction(Matchers.anyString())).thenReturn(action1);
 195                 StringWriter sw = new StringWriter();
 196                 PrintWriter writer = new PrintWriter(sw);
 197                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 198                 raptorControllerAsync.RaptorSearch(mockedRequest, mockedResponse);
 199         }
 200
 201         public String test(HttpServletRequest request, String str) {
 202                 return "test";
 203         }
 204
 205         @Test(expected = java.lang.NullPointerException.class)
 206         public void RaptorSearchClassNotFoundExceptionTest() throws Exception {
 207                 User user = new User();
 208                 user.setOrgUserId("test12");
 209                 Mockito.when(UserUtils.getUserSession(mockedRequest)).thenReturn(user);
 210                 ServletContext servletContext = PowerMockito.mock(ServletContext.class);
 211                 Mockito.when(mockedRequest.getSession().getServletContext()).thenReturn(servletContext);
 212                 PowerMockito.mockStatic(Globals.class);
 213                 Mockito.when(Globals.isSystemInitialized()).thenReturn(true);
 214                 Mockito.when(Globals.getRaptorActionMapping()).thenReturn(actionMapping);
 215                 Action action1 = new Action("test", "RaptorControllerAsyncTest", "test", "test");
 216                 Mockito.when(actionMapping.getAction(Matchers.anyString())).thenReturn(action1);
 217                 StringWriter sw = new StringWriter();
 218                 PrintWriter writer = new PrintWriter(sw);
 219                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 220                 raptorControllerAsync.RaptorSearch(mockedRequest, mockedResponse);
 221         }
 222
 223         @Test(expected = java.lang.NullPointerException.class)
 224         public void RaptorSearchMethodNotFoundExceptionTest() throws Exception {
 225                 User user = new User();
 226                 user.setOrgUserId("test12");
 227                 Mockito.when(UserUtils.getUserSession(mockedRequest)).thenReturn(user);
 228                 ServletContext servletContext = PowerMockito.mock(ServletContext.class);
 229                 Mockito.when(mockedRequest.getSession().getServletContext()).thenReturn(servletContext);
 230                 PowerMockito.mockStatic(Globals.class);
 231                 Mockito.when(Globals.isSystemInitialized()).thenReturn(true);
 232                 Mockito.when(Globals.getRaptorActionMapping()).thenReturn(actionMapping);
 233                 Action action1 = new Action("test",
 234                                 "org.onap.portalsdk.analytics.system.fusion.service.RaptorControllerAsyncTest", "newtest", "test");
 235                 Mockito.when(actionMapping.getAction(Matchers.anyString())).thenReturn(action1);
 236                 StringWriter sw = new StringWriter();
 237                 PrintWriter writer = new PrintWriter(sw);
 238                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 239                 raptorControllerAsync.RaptorSearch(mockedRequest, mockedResponse);
 240         }
 241
 242         public void test1(HttpServletRequest request, String str) {
 243                 throw new MethodInvocationException("test");
 244         }
 245
 246         @Test(expected = java.lang.NullPointerException.class)
 247         public void RaptorSearchMethodInvocationFoundExceptionTest() throws Exception {
 248                 User user = new User();
 249                 user.setOrgUserId("test12");
 250                 Mockito.when(UserUtils.getUserSession(mockedRequest)).thenReturn(user);
 251                 ServletContext servletContext = PowerMockito.mock(ServletContext.class);
 252                 Mockito.when(mockedRequest.getSession().getServletContext()).thenReturn(servletContext);
 253                 PowerMockito.mockStatic(Globals.class);
 254                 Mockito.when(Globals.isSystemInitialized()).thenReturn(true);
 255                 Mockito.when(Globals.getRaptorActionMapping()).thenReturn(actionMapping);
 256                 Action action1 = new Action("test",
 257                                 "org.onap.portalsdk.analytics.system.fusion.service.RaptorControllerAsyncTest", "test1", null);
 258                 Mockito.when(actionMapping.getAction(Matchers.anyString())).thenReturn(action1);
 259                 StringWriter sw = new StringWriter();
 260                 PrintWriter writer = new PrintWriter(sw);
 261                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 262                 raptorControllerAsync.RaptorSearch(mockedRequest, mockedResponse);
 263         }
 264
 265         @Test(expected = java.lang.NullPointerException.class)
 266         public void RaptorSearchRaptorExceptionTest() throws Exception {
 267                 User user = new User();
 268                 user.setOrgUserId("test12");
 269                 Mockito.when(UserUtils.getUserSession(mockedRequest)).thenReturn(user);
 270                 ServletContext servletContext = PowerMockito.mock(ServletContext.class);
 271                 Mockito.when(mockedRequest.getSession().getServletContext()).thenReturn(servletContext);
 272                 PowerMockito.mockStatic(Globals.class);
 273                 Mockito.when(Globals.isSystemInitialized()).thenReturn(true);
 274                 Mockito.when(Globals.getRaptorActionMapping()).thenReturn(actionMapping);
 275                 Mockito.when(actionMapping.getAction(Matchers.anyString())).thenReturn(null);
 276                 StringWriter sw = new StringWriter();
 277                 PrintWriter writer = new PrintWriter(sw);
 278                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 279                 raptorControllerAsync.RaptorSearch(mockedRequest, mockedResponse);
 280         }
 281
 282         @Test
 283         public void RaptorSearchNoUserTest() throws Exception {
 284
 285                 Mockito.when(UserUtils.getUserSession(mockedRequest)).thenReturn(null);
 286                 ServletContext servletContext = PowerMockito.mock(ServletContext.class);
 287                 Mockito.when(mockedRequest.getSession().getServletContext()).thenReturn(servletContext);
 288                 PowerMockito.mockStatic(Globals.class);
 289                 Mockito.when(Globals.isSystemInitialized()).thenReturn(true);
 290                 Mockito.when(Globals.getRaptorActionMapping()).thenReturn(actionMapping);
 291                 Action action1 = new Action("test",
 292                                 "org.onap.portalsdk.analytics.system.fusion.service.RaptorControllerAsyncTest", "test1", null);
 293                 Mockito.when(actionMapping.getAction(Matchers.anyString())).thenReturn(action1);
 294                 StringWriter sw = new StringWriter();
 295                 PrintWriter writer = new PrintWriter(sw);
 296                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 297                 raptorControllerAsync.RaptorSearch(mockedRequest, mockedResponse);
 298         }
 299
 300         @Test(expected = java.lang.NullPointerException.class)
 301         public void RaptorSearchGlobalyTest() throws Exception {
 302                 User user = new User();
 303                 user.setOrgUserId("test12");
 304                 Mockito.when(UserUtils.getUserSession(mockedRequest)).thenReturn(user);
 305                 ServletContext servletContext = PowerMockito.mock(ServletContext.class);
 306                 Mockito.when(mockedRequest.getSession().getServletContext()).thenReturn(servletContext);
 307                 PowerMockito.mockStatic(Globals.class);
 308                 Mockito.when(Globals.isSystemInitialized()).thenReturn(false);
 309                 Mockito.when(Globals.getRaptorActionMapping()).thenReturn(actionMapping);
 310                 Action action1 = new Action("test",
 311                                 "org.onap.portalsdk.analytics.system.fusion.service.RaptorControllerAsyncTest", "test", "test");
 312                 Mockito.when(actionMapping.getAction(Matchers.anyString())).thenReturn(action1);
 313                 StringWriter sw = new StringWriter();
 314                 PrintWriter writer = new PrintWriter(sw);
 315                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 316                 ErrorHandler errorHandler = PowerMockito.mock(ErrorHandler.class);
 317                 Mockito.when(errorHandler.processFatalErrorJSON(Matchers.any(HttpServletRequest.class), Matchers.any(RaptorException.class))).thenReturn("test");
 318
 319
 320                 raptorControllerAsync.setViewName("test");
 321                 raptorControllerAsync.RaptorSearch(mockedRequest, mockedResponse);
 322         }
 323
 324         @Test
 325         public void listColumnsTest() throws Exception {
 326                 List<DataColumnType> reportColumnList = new ArrayList<>();
 327                 DataColumnType dataColumnType = new DataColumnType();
 328                 dataColumnType.setColId("test");
 329                 dataColumnType.setColName("testname");
 330                 reportColumnList.add(dataColumnType);
 331                 ReportDefinition reportDefinition = PowerMockito.mock(ReportDefinition.class);
 332                 reportDefinition.setReportName("test");
 333                 Mockito.when(reportDefinition.getAllColumns()).thenReturn(reportColumnList);
 334                 Mockito.when(mockedRequest.getSession().getAttribute(AppConstants.SI_REPORT_DEFINITION))
 335                                 .thenReturn(reportDefinition);
 336                 ArrayList<ColumnJSON> listJSON = new ArrayList<ColumnJSON>();
 337                 ColumnJSON columnJSON = new ColumnJSON();
 338                 columnJSON.setId("test");
 339                 columnJSON.setName("testname");
 340                 listJSON.add(columnJSON);
 341                 assertEquals(listJSON.get(0).getId(),
 342                                 raptorControllerAsync.listColumns(mockedRequest, mockedResponse).get(0).getId());
 343         }
 344
 345         @Test
 346         public void list_drilldown_reports() throws Exception {
 347                 PowerMockito.mockStatic(Globals.class);
 348                 PowerMockito.mockStatic(DbUtils.class);
 349
 350                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 351                 ResultSet rs = PowerMockito.mock(ResultSet.class);
 352                 ResultSetMetaData rsmd = PowerMockito.mock(ResultSetMetaData.class);
 353                 Mockito.when(rsmd.getColumnCount()).thenReturn(1);
 354                 Mockito.when(rs.getMetaData()).thenReturn(rsmd);
 355                 DataSet datset = PowerMockito.mock(DataSet.class);
 356                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 357                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 358                 Mockito.when(Globals.getNewScheduleData()).thenReturn("test");
 359                 CustomReportType customReportType = new CustomReportType();
 360                 customReportType.setReportType("test");
 361                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 362                                 "1", true);
 363                 ReportDefinition reportDefinition = PowerMockito.mock(ReportDefinition.class);
 364                 Mockito.doNothing().when(reportDefinition).generateWizardSequence(null);
 365                 reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 366                 PowerMockito.mockStatic(DataCache.class);
 367                 PowerMockito.mockStatic(AppUtils.class);
 368                 Vector<IdNameValue> reportnames = new Vector<>();
 369                 IdNameValue idNameValue = new IdNameValue();
 370                 idNameValue.setId("1");
 371                 reportnames.add(idNameValue);
 372                 Mockito.when(DataCache.getPublicReportIdNames()).thenReturn(reportnames);
 373                 reportDefinition.setReportName("test");
 374                 Mockito.when(mockedRequest.getSession().getAttribute(AppConstants.SI_REPORT_DEFINITION))
 375                                 .thenReturn(reportDefinition);
 376                 Mockito.when(AppUtils.getUserID(mockedRequest)).thenReturn("test12");
 377                 Vector userRoles = new Vector<>();
 378                 userRoles.add(idNameValue);
 379                 Mockito.when(AppUtils.getUserRoles(mockedRequest)).thenReturn(userRoles);
 380
 381                 Vector groupReportIdNames = new Vector<>();
 382                 groupReportIdNames.add(idNameValue);
 383                 Mockito.when(DataCache.getGroupAccessibleReportIdNames("test12", userRoles)).thenReturn(groupReportIdNames);
 384                 Mockito.when(DataCache.getPrivateAccessibleReportIdNames("test12", userRoles)).thenReturn(groupReportIdNames);
 385                 ServletContext servletContext = PowerMockito.mock(ServletContext.class);
 386                 Mockito.when(mockedRequest.getSession().getServletContext()).thenReturn(servletContext);
 387                 Mockito.when(Globals.isSystemInitialized()).thenReturn(true);
 388                 assertEquals(3, raptorControllerAsync.list_drilldown_reports(mockedRequest, mockedResponse).size());
 389         }
 390
 391         @Test
 392         public void list_drilldown_reportsNull() throws Exception {
 393                 PowerMockito.mockStatic(Globals.class);
 394                 PowerMockito.mockStatic(DbUtils.class);
 395
 396                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 397                 ResultSet rs = PowerMockito.mock(ResultSet.class);
 398                 ResultSetMetaData rsmd = PowerMockito.mock(ResultSetMetaData.class);
 399                 Mockito.when(rsmd.getColumnCount()).thenReturn(1);
 400                 Mockito.when(rs.getMetaData()).thenReturn(rsmd);
 401                 DataSet datset = PowerMockito.mock(DataSet.class);
 402                 // datset = new DataSet(rs);
 403                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 404                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 405                 Mockito.when(Globals.getNewScheduleData()).thenReturn("test");
 406                 CustomReportType customReportType = new CustomReportType();
 407                 customReportType.setReportType("test");
 408                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 409                                 "1", true);
 410                 ReportDefinition reportDefinition = PowerMockito.mock(ReportDefinition.class);
 411                 Mockito.doNothing().when(reportDefinition).generateWizardSequence(null);
 412                 reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 413                 PowerMockito.mockStatic(DataCache.class);
 414                 PowerMockito.mockStatic(AppUtils.class);
 415                 Vector<IdNameValue> reportnames = new Vector<>();
 416                 IdNameValue idNameValue = new IdNameValue();
 417                 idNameValue.setId("-1");
 418                 reportnames.add(idNameValue);
 419                 Mockito.when(DataCache.getPublicReportIdNames()).thenReturn(reportnames);
 420                 reportDefinition.setReportName("test");
 421                 Mockito.when(mockedRequest.getSession().getAttribute(AppConstants.SI_REPORT_DEFINITION))
 422                                 .thenReturn(reportDefinition);
 423                 Mockito.when(AppUtils.getUserID(mockedRequest)).thenReturn("test12");
 424                 Vector userRoles = new Vector<>();
 425                 userRoles.add(idNameValue);
 426                 Mockito.when(AppUtils.getUserRoles(mockedRequest)).thenReturn(userRoles);
 427
 428                 Vector groupReportIdNames = new Vector<>();
 429                 groupReportIdNames.add(idNameValue);
 430                 Mockito.when(DataCache.getGroupAccessibleReportIdNames("test12", userRoles)).thenReturn(groupReportIdNames);
 431                 Mockito.when(DataCache.getPrivateAccessibleReportIdNames("test12", userRoles)).thenReturn(groupReportIdNames);
 432                 ServletContext servletContext = PowerMockito.mock(ServletContext.class);
 433                 Mockito.when(mockedRequest.getSession().getServletContext()).thenReturn(servletContext);
 434                 Mockito.when(Globals.isSystemInitialized()).thenReturn(true);
 435                 assertEquals(0, raptorControllerAsync.list_drilldown_reports(mockedRequest, mockedResponse).size());
 436         }
 437
 438         @Test
 439         public void listFormFields() throws Exception
 440         {
 441                 PowerMockito.mockStatic(Globals.class);
 442                 PowerMockito.mockStatic(DbUtils.class);
 443
 444                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 445                 ResultSet rs = PowerMockito.mock(ResultSet.class);
 446                 ResultSetMetaData rsmd = PowerMockito.mock(ResultSetMetaData.class);
 447                 Mockito.when(rsmd.getColumnCount()).thenReturn(1);
 448                 Mockito.when(rs.getMetaData()).thenReturn(rsmd);
 449                 DataSet datset = PowerMockito.mock(DataSet.class);
 450                 // datset = new DataSet(rs);
 451                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 452                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 453                 Mockito.when(Globals.getNewScheduleData()).thenReturn("test");
 454                 CustomReportType customReportType = new CustomReportType();
 455                 customReportType.setReportType("test");
 456                 FormFieldList formFieldList= new FormFieldList();
 457                 formFieldList.setComment("test");
 458                 customReportType.setFormFieldList(formFieldList);
 459                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 460                                 "1", true);
 461                 ReportDefinition reportDefinition = PowerMockito.mock(ReportDefinition.class);
 462                 Mockito.doNothing().when(reportDefinition).generateWizardSequence(null);
 463                 reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 464
 465                 Mockito.when(mockedRequest.getSession().getAttribute(AppConstants.SI_REPORT_DEFINITION)).thenReturn(reportDefinition);
 466
 467                 assertEquals(raptorControllerAsync.listFormFields(mockedRequest, mockedResponse).size(), 0);
 468         }
 469
 470         @Test
 471         public void listFormFieldsTest() throws Exception
 472         {
 473                 PowerMockito.mockStatic(Globals.class);
 474                 PowerMockito.mockStatic(DbUtils.class);
 475
 476                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 477                 ResultSet rs = PowerMockito.mock(ResultSet.class);
 478                 ResultSetMetaData rsmd = PowerMockito.mock(ResultSetMetaData.class);
 479                 Mockito.when(rsmd.getColumnCount()).thenReturn(1);
 480                 Mockito.when(rs.getMetaData()).thenReturn(rsmd);
 481                 DataSet datset = PowerMockito.mock(DataSet.class);
 482                 // datset = new DataSet(rs);
 483                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 484                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 485                 Mockito.when(Globals.getNewScheduleData()).thenReturn("test");
 486                 CustomReportType customReportType = new CustomReportType();
 487                 customReportType.setReportType("test");
 488                 FormFieldList formFieldList= PowerMockito.mock(FormFieldList.class);
 489                 formFieldList.setComment("test");
 490                 customReportType.setFormFieldList(formFieldList);
 491                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 492                                 "1", true);
 493                 ReportDefinition reportDefinition = PowerMockito.mock(ReportDefinition.class);
 494                 Mockito.doNothing().when(reportDefinition).generateWizardSequence(null);
 495                 reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 496                 List<FormFieldType> formField = new ArrayList<>();
 497                 FormFieldType formFieldType = new FormFieldType();
 498                 formFieldType.setFieldId("id");
 499                 formField.add(formFieldType);
 500                 Mockito.when(formFieldList.getFormField()).thenReturn(formField);
 501                 Mockito.when(mockedRequest.getSession().getAttribute(AppConstants.SI_REPORT_DEFINITION)).thenReturn(reportDefinition);
 502                 assertEquals(raptorControllerAsync.listFormFields(mockedRequest, mockedResponse).size(), 1);
 503         }
 504
 505         @Test
 506         public void listFormFieldsNullTest() throws Exception
 507         {
 508                 PowerMockito.mockStatic(Globals.class);
 509                 PowerMockito.mockStatic(DbUtils.class);
 510
 511                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 512                 ResultSet rs = PowerMockito.mock(ResultSet.class);
 513                 ResultSetMetaData rsmd = PowerMockito.mock(ResultSetMetaData.class);
 514                 Mockito.when(rsmd.getColumnCount()).thenReturn(1);
 515                 Mockito.when(rs.getMetaData()).thenReturn(rsmd);
 516                 DataSet datset = PowerMockito.mock(DataSet.class);
 517                 // datset = new DataSet(rs);
 518                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 519                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 520                 Mockito.when(Globals.getNewScheduleData()).thenReturn("test");
 521                 CustomReportType customReportType = new CustomReportType();
 522                 customReportType.setReportType("test");
 523                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 524                                 "1", true);
 525                 ReportDefinition reportDefinition = PowerMockito.mock(ReportDefinition.class);
 526                 Mockito.doNothing().when(reportDefinition).generateWizardSequence(null);
 527                 reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 528                                 Mockito.when(mockedRequest.getSession().getAttribute(AppConstants.SI_REPORT_DEFINITION)).thenReturn(reportDefinition);
 529                 assertEquals(raptorControllerAsync.listFormFields(mockedRequest, mockedResponse).size(),0);
 530         }
 531
 532         @Test(expected = java.lang.NullPointerException.class)
 533         public void saveDefTabWiseDataIfIdInSessionTest() throws Exception
 534         {
 535                 DefinitionJSON definitionJSON = new DefinitionJSON();
 536                 definitionJSON.setTabId("1");
 537                 PowerMockito.mockStatic(ReportLoader.class);
 538                 Mockito.when(ReportLoader.loadCustomReportXML("1")).thenReturn("test");
 539                 ReportRuntime rr = PowerMockito.mock(ReportRuntime.class);
 540                 PowerMockito.mockStatic(Globals.class);
 541                 PowerMockito.mockStatic(DbUtils.class);
 542
 543                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 544                 ResultSet rs = PowerMockito.mock(ResultSet.class);
 545                 ResultSetMetaData rsmd = PowerMockito.mock(ResultSetMetaData.class);
 546                 Mockito.when(rsmd.getColumnCount()).thenReturn(1);
 547                 Mockito.when(rs.getMetaData()).thenReturn(rsmd);
 548                 DataSet datset = PowerMockito.mock(DataSet.class);
 549                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 550                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 551                 Mockito.when(Globals.getNewScheduleData()).thenReturn("test");
 552                 CustomReportType customReportType = new CustomReportType();
 553                 customReportType.setReportType("test");
 554                 DataSourceList list = new DataSourceList();
 555                 customReportType.setDataSourceList(list);
 556                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 557                                 "1", true);
 558                 rr = new ReportRuntime(reportWrapper);
 559                 Mockito.when(mockedRequest.getSession().getAttribute(AppConstants.SI_REPORT_RUNTIME)).thenReturn(null);
 560                 Mockito.when(mockedRequest.getSession().getAttribute(AppConstants.SI_REPORT_RUNTIME)).thenReturn(rr);
 561                 raptorControllerAsync.saveDefTabWiseData("test", definitionJSON, mockedRequest, mockedResponse);
 562         }
 563
 564
 565         @Test
 566         public void reportChartReceiveTest() throws Exception
 567         {
 568
 569                 PowerMockito.mockStatic(ReportLoader.class);
 570                 Mockito.when(ReportLoader.loadCustomReportXML("1")).thenReturn("test");
 571                 ReportRuntime rr = mockRunTimeReport.mockReportRuntime();
 572                 PowerMockito.mockStatic(Globals.class);
 573                 PowerMockito.mockStatic(DbUtils.class);
 574                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 575                 ResultSet rs = PowerMockito.mock(ResultSet.class);
 576                 ResultSetMetaData rsmd = PowerMockito.mock(ResultSetMetaData.class);
 577                 Mockito.when(rsmd.getColumnCount()).thenReturn(1);
 578                 Mockito.when(rs.getMetaData()).thenReturn(rsmd);
 579                 DataSet datset = PowerMockito.mock(DataSet.class);
 580                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 581                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 582                 Mockito.when(Globals.getNewScheduleData()).thenReturn("test");
 583                 CustomReportType customReportType = new CustomReportType();
 584                 customReportType.setReportType("test");
 585                 DataSourceList list = new DataSourceList();
 586                 customReportType.setDataSourceList(list);
 587                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 588                                 "1", true);
 589         Mockito.when( mockedRequest.getSession().getAttribute(AppConstants.SI_REPORT_RUNTIME)).thenReturn(rr);
 590         ChartJSON chartJSON = mockChartJSON();
 591         raptorControllerAsync.reportChartReceive(chartJSON, mockedRequest, mockedResponse);
 592
 593         }
 594
 595
 596         public ChartJSON mockChartJSON()
 597         {
 598                 ChartJSON chartJSON = new ChartJSON();
 599         chartJSON.setAnimation(false);
 600         chartJSON.setWidth("width");
 601         chartJSON.setHeight("height");
 602         chartJSON.setShowTitle(true);
 603         BarChartOptions barChartOptions= new BarChartOptions();
 604         chartJSON.setBarChartOptions(barChartOptions);
 605         DomainAxisJSON domainAxisJSON= new DomainAxisJSON();
 606         domainAxisJSON.setValue("test");
 607         chartJSON.setDomainAxisJSON(domainAxisJSON);
 608         ArrayList<RangeAxisJSON> rangeAxisJSONList = new ArrayList<>();
 609         RangeAxisJSON rangeAxisJSON = new RangeAxisJSON();
 610         rangeAxisJSONList.add(rangeAxisJSON);
 611         chartJSON.setRangeAxisRemoveList(rangeAxisJSONList);
 612         ChartTypeJSON chartTypeJSON = new ChartTypeJSON();
 613         chartTypeJSON.setValue("BarChart3D");
 614         chartJSON.setChartTypeJSON(chartTypeJSON);
 615         chartJSON.setRangeAxisList(rangeAxisJSONList);
 616         CommonChartOptions commonChartOptions = new CommonChartOptions();
 617         commonChartOptions.setLegendLabelAngle("test");
 618         commonChartOptions.setLegendPosition("legendPosition");
 619         commonChartOptions.setHideLegend(false);
 620         chartJSON.setCommonChartOptions(commonChartOptions);
 621         return chartJSON;
 622         }
 623
 624         @Test
 625         public void listChildReportColsTest() throws Exception {
 626                 ReportRuntime rr = Mockito.mock(ReportRuntime.class);
 627                 PowerMockito.whenNew(ReportHandler.class).withNoArguments().thenReturn(reportHandler);
 628                 Mockito.when(reportHandler.loadReportRuntime(Mockito.any(HttpServletRequest.class), Mockito.anyString(), Mockito.anyBoolean())).thenReturn(rr);
 629                 List<DataColumnType> dataColumnTypeList = new ArrayList<>();
 630                 DataColumnType dataColumnType = new DataColumnType();
 631                 dataColumnType.setColName("test");
 632                 dataColumnType.setColId("1");
 633                 dataColumnTypeList.add(dataColumnType);
 634                 Mockito.when(rr.getAllColumns()).thenReturn(dataColumnTypeList);
 635                 raptorControllerAsync.listChildReportCols("reportID", mockedRequest, mockedResponse);
 636         }
 637
 638         @Test
 639         public void listChildReportFormFieldsTest() throws Exception {
 640                 ReportRuntime rr = Mockito.mock(ReportRuntime.class);
 641                 PowerMockito.whenNew(ReportHandler.class).withNoArguments().thenReturn(reportHandler);
 642                 Mockito.when(reportHandler.loadReportRuntime(Mockito.any(HttpServletRequest.class), Mockito.anyString(), Mockito.anyBoolean())).thenReturn(rr);
 643                 List predefinedValues = new ArrayList<>();
 644                 ReportWrapper rw = PowerMockito.mock(ReportWrapper.class);
 645                 ReportFormFields reportFormFields = new ReportFormFields(rw, mockedRequest);
 646                 FormField formField = new FormField("test", "fieldDisplayName", "TEXTAREA", "validationType", false,
 647                                 "defaultValue", "helpText", predefinedValues, true, "dependsOn", null, null, "rangeStartDateSQL",
 648                                 "rangeEndDateSQL", "multiSelectListSize");
 649                 FormField formField1 = new FormField("test", "fieldDisplayName", "TEXTAREA", "validationType", false,
 650                                 "defaultValue", "helpText", predefinedValues, false, "dependsOn", null, null, "rangeStartDateSQL",
 651                                 "rangeEndDateSQL", "multiSelectListSize");
 652                 FormField formField2 = new FormField("test", "fieldDisplayName", "TEXTAREA", "validationType", false,
 653                                 "defaultValue", "helpText", predefinedValues, false, "dependsOn", null, null, "rangeStartDateSQL",
 654                                 "rangeEndDateSQL", "multiSelectListSize");
 655
 656                 reportFormFields.add(formField);
 657                 reportFormFields.add(formField1);
 658                 reportFormFields.add(formField2);
 659                 Mockito.when(rr.getReportFormFields()).thenReturn(reportFormFields);
 660                 raptorControllerAsync.listChildReportFormFields("reportID", mockedRequest, mockedResponse);
 661         }
 662
 663         @Test
 664         public void getReportSecurityUsersTest() throws Exception {
 665                 ReportDefinition rdef = Mockito.mock(ReportDefinition.class);
 666                 Mockito.when(mockedRequest.getSession().getAttribute(AppConstants.SI_REPORT_DEFINITION)).thenReturn(rdef);
 667                 Vector vc = new Vector<>();
 668                 vc.add(new SecurityEntry("1", "test", true));
 669                 Mockito.when(rdef.getReportUsers(mockedRequest)).thenReturn(vc);
 670                 raptorControllerAsync.getReportSecurityUsers(mockedRequest);
 671         }
 672
 673         @Test
 674         public void getReportSecurityRolesTest() throws Exception {
 675                 ReportDefinition rdef = Mockito.mock(ReportDefinition.class);
 676                 Mockito.when(mockedRequest.getSession().getAttribute(AppConstants.SI_REPORT_DEFINITION)).thenReturn(rdef);
 677                 Vector vc = new Vector<>();
 678                 vc.add(new SecurityEntry("1", "test", true));
 679                 Mockito.when(rdef.getReportRoles(mockedRequest)).thenReturn(vc);
 680                 raptorControllerAsync.getReportSecurityRoles(mockedRequest);
 681         }
 682
 683         public ReportDefinition mockReportDefinition() throws RaptorException {
 684                 PowerMockito.mockStatic(Globals.class);
 685                 PowerMockito.mockStatic(DbUtils.class);
 686                 Mockito.when(Globals.getReportUserAccess()).thenReturn("test");
 687                 DataSet datset = PowerMockito.mock(DataSet.class);
 688                 Mockito.when(datset.getString(Matchers.anyInt(), Matchers.anyInt())).thenReturn(null);
 689                 Mockito.when(DbUtils.executeQuery(Matchers.anyString())).thenReturn(datset);
 690                 CustomReportType customReportType = new CustomReportType();
 691                 customReportType.setReportType("test");
 692                 FormFieldList formFieldList = new FormFieldList();
 693                 formFieldList.setComment("test");
 694                 customReportType.setFormFieldList(formFieldList);
 695                 customReportType.setPublic(true);
 696                 customReportType.setReportType("test");
 697                 customReportType.setReportTitle("test");
 698                 ReportWrapper reportWrapper = new ReportWrapper(customReportType, "-1", "test", "testId", "test", "test", "1",
 699                                 "1", true);
 700                 reportWrapper.setReportDefType("SQL-based");
 701                 ReportDefinition reportDefinition = new ReportDefinition(reportWrapper, mockedRequest);
 702                 return reportDefinition;
 703         }
 704         @Test
 705         public void retrieveDefTabWiseDataTest() throws Exception {
 706                 PowerMockito.mockStatic(AppUtils.class);
 707                 ReportDefinition rdef = mockReportDefinition();
 708                 Mockito.when(mockedRequest.getSession().getAttribute(AppConstants.SI_REPORT_DEFINITION)).thenReturn(rdef);
 709                 Map<String, String> pathVariables = new HashMap<>();
 710                 pathVariables.put("id", "InSession");
 711                 pathVariables.put("detailId", "test");
 712                 Vector vc = new Vector<>();
 713                 vc.add("test");
 714                 PowerMockito.when(AppUtils.getQuickLinksMenuIDs()).thenReturn(vc);
 715                 raptorControllerAsync.retrieveDefTabWiseData(pathVariables, mockedRequest, mockedResponse);
 716         }
 717
 718
 719
 720 }