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