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.definition;
  39
  40 import static org.junit.Assert.assertEquals;
  41 import static org.junit.Assert.assertFalse;
  42 import static org.junit.Assert.assertTrue;
  43
  44 import java.io.FileInputStream;
  45 import java.io.InputStream;
  46 import java.sql.Connection;
  47 import java.sql.PreparedStatement;
  48 import java.sql.ResultSet;
  49 import java.sql.SQLException;
  50 import java.util.ArrayList;
  51 import java.util.List;
  52 import java.util.Vector;
  53
  54 import javax.servlet.http.HttpServletRequest;
  55 import javax.servlet.http.HttpSession;
  56 import org.apache.commons.io.IOUtils;
  57 import org.junit.Before;
  58 import org.junit.Test;
  59 import org.junit.runner.RunWith;
  60 import org.mockito.Matchers;
  61 import org.mockito.Mock;
  62 import org.mockito.Mockito;
  63 import org.mockito.MockitoAnnotations;
  64 import org.onap.portalsdk.analytics.error.RaptorException;
  65 import org.onap.portalsdk.analytics.error.ReportSQLException;
  66 import org.onap.portalsdk.analytics.model.base.IdNameValue;
  67 import org.onap.portalsdk.analytics.model.runtime.FormField;
  68 import org.onap.portalsdk.analytics.model.runtime.ReportParamValues;
  69 import org.onap.portalsdk.analytics.model.runtime.ReportRuntime;
  70 import org.onap.portalsdk.analytics.system.AppUtils;
  71 import org.onap.portalsdk.analytics.system.ConnectionUtils;
  72 import org.onap.portalsdk.analytics.system.DbUtils;
  73 import org.onap.portalsdk.analytics.system.Globals;
  74 import org.onap.portalsdk.analytics.util.AppConstants;
  75 import org.onap.portalsdk.analytics.util.DataSet;
  76 import org.onap.portalsdk.analytics.util.RemDbInfo;
  77 import org.onap.portalsdk.analytics.xmlobj.DataColumnType;
  78 import org.onap.portalsdk.analytics.xmlobj.DataSourceType;
  79 import org.onap.portalsdk.analytics.xmlobj.FormFieldList;
  80 import org.onap.portalsdk.analytics.xmlobj.FormFieldType;
  81 import org.owasp.esapi.ESAPI;
  82 import org.owasp.esapi.Encoder;
  83 import org.powermock.api.mockito.PowerMockito;
  84 import org.powermock.core.classloader.annotations.PrepareForTest;
  85 import org.powermock.modules.junit4.PowerMockRunner;
  86
  87 import com.mchange.v2.debug.ThreadNameStackTraceRecorder;
  88
  89 @RunWith(PowerMockRunner.class)
  90 @PrepareForTest({ AppUtils.class, Globals.class, DbUtils.class, AppUtils.class, ESAPI.class, ConnectionUtils.class, ReportSchedule.class})
  91
  92 public class ReportScheduleTest {
  93
  94         ReportSchedule reportSchedule;
  95
  96         private String REPORT_ID="1000";
  97         private String USER_ID="USER#1";
  98
  99         @Mock
 100         HttpServletRequest httpServletRequest;
 101
 102         @Mock
 103         HttpSession httpSession;
 104
 105         @Mock
 106         ReportRuntime reportRuntime;
 107
 108         @Mock
 109         ReportDefinition reportDefinition;
 110
 111         @Mock
 112         Encoder encoder;
 113
 114         @Mock
 115         DataSet dataSet1;
 116
 117         @Mock
 118         Connection connection;
 119
 120         @Mock
 121         PreparedStatement preparedStatement;
 122
 123         @Mock
 124         ResultSet resultSet;
 125
 126         @Mock
 127         java.sql.Clob clob;
 128
 129         @Mock
 130         FileInputStream fileInputStream;
 131
 132         @Before
 133         public void setUp() throws Exception {
 134
 135                 PowerMockito.mockStatic(Globals.class);
 136                 PowerMockito.mockStatic(AppUtils.class);
 137                 PowerMockito.mockStatic(DbUtils.class);
 138                 PowerMockito.mockStatic(AppUtils.class);
 139                 PowerMockito.mockStatic(ESAPI.class);
 140                 PowerMockito.mockStatic(ConnectionUtils.class);
 141
 142                 MockitoAnnotations.initMocks(this);
 143
 144                 Mockito.when(httpSession.getAttribute(AppConstants.SI_REPORT_RUNTIME)).thenReturn(reportRuntime);
 145                 Mockito.when(httpServletRequest.getSession()).thenReturn(httpSession);
 146
 147                 Mockito.when(reportRuntime.getReportID()).thenReturn(REPORT_ID);
 148                 Mockito.when(AppUtils.getUserID(httpServletRequest)).thenReturn("USER1");
 149
 150                 PowerMockito.when(ESAPI.encoder()).thenReturn(encoder);
 151
 152                 createInstanceOfReportSchedule_case1();
 153                 createInstanceOfReportSchedule_case2();
 154
 155         }
 156
 157         private void createInstanceOfReportSchedule_case1() throws Exception {
 158                 String load_schedule_data = "SELECT rs.enabled_yn, DATE_FORMAT(rs.start_date, '%m/%d/%Y') start_date, DATE_FORMAT(rs.end_date, '%m/%d/%Y') end_date, DATE_FORMAT(rs.run_date, '%m/%d/%Y') run_date, coalesce(DATE_FORMAT(rs.run_date, '%h'), '12') run_hour, coalesce(DATE_FORMAT(rs.run_date, '%i'), '00') run_min, coalesce(DATE_FORMAT(rs.run_date, '%p'), 'AM') run_ampm, rs.recurrence, rs.conditional_yn, rs.notify_type, rs.max_row, rs.initial_formfields, rs.schedule_id, coalesce(DATE_FORMAT(rs.end_date, '%h'), '11') end_hour, coalesce(DATE_FORMAT(rs.end_date, '%i'), '45') end_min, coalesce(DATE_FORMAT(rs.end_date, '%p'), 'PM') end_ampm, encrypt_yn, attachment_yn FROM cr_report_schedule rs WHERE rs.rep_id = [reportID]";
 159                 String load_schedule_getid = "SELECT rsu.user_id, concat(fuser.last_name,', ',fuser.first_name), fuser.login_id FROM cr_report_schedule_users rsu, fn_user fuser WHERE rsu.rep_id = [reportID]  AND rsu.schedule_id = [getScheduleID()] and rsu.user_id IS NOT NULL and rsu.user_id = fuser.user_id";
 160                 String load_schedule_users = "SELECT rsu.role_id FROM cr_report_schedule_users rsu WHERE rsu.rep_id = [reportID] AND rsu.schedule_id = [getScheduleID()] AND rsu.role_id IS NOT NULL";
 161
 162                 PowerMockito.when(Globals.getLoadScheduleData()).thenReturn(load_schedule_data);
 163                 PowerMockito.when(Globals.getLoadScheduleGetId()).thenReturn(load_schedule_getid);
 164                 PowerMockito.when(Globals.getLoadScheduleUsers()).thenReturn(load_schedule_users);
 165                 PowerMockito.when(AppUtils.isAdminUser(httpServletRequest)).thenReturn(true);
 166                 PowerMockito.when(Globals.isWeblogicServer()).thenReturn(true);
 167
 168                 //reportSchedule = new ReportSchedule(REPORT_ID, USER_ID, false, httpServletRequest);
 169                 //String dataArray[] = {"Y", "10/10/2018", "10/10/2999", "01/11/2018", "9", "10", "AM", "Y", "Y", "0", "512","", "2000", "10", "30", "PM," };
 170
 171                 PowerMockito.when(DbUtils.getConnection()).thenReturn(connection);
 172
 173                 Mockito.when(connection.prepareStatement(Mockito.anyString())).thenReturn(preparedStatement);
 174                 Mockito.when(preparedStatement.executeQuery()).thenReturn(resultSet);
 175                 Mockito.when(resultSet.next()).thenReturn(true);
 176                 Mockito.when(resultSet.getClob(Mockito.anyInt())).thenReturn(clob);
 177
 178                 String source = "This is the source of my input stream";
 179                 InputStream inputStream = IOUtils.toInputStream(source, "UTF-8");
 180
 181                 Mockito.when(clob.getAsciiStream()).thenReturn(inputStream);
 182
 183                 //SI_REPORT_RUNTIME
 184                 PowerMockito.when(DbUtils.executeQuery(Mockito.anyString())).thenReturn(dataSet1);
 185                 Mockito.when(dataSet1.getRowCount()).thenReturn(1);
 186
 187                 Mockito.when(dataSet1.getString(Mockito.anyInt(), Mockito.anyInt())).thenReturn("Some Value1");
 188                 Mockito.when(dataSet1.getString(Mockito.anyInt(), Mockito.anyString())).thenReturn("Some Value2");
 189
 190                 reportSchedule = new ReportSchedule(REPORT_ID, USER_ID, true, httpServletRequest);
 191                 reportSchedule.setEncryptMode("test");
 192                 reportSchedule.setEndAMPM("AM");
 193                 reportSchedule.setEndHour("10");
 194                 reportSchedule.setEndMin("00");
 195                 reportSchedule.addZero("0");
 196
 197
 198
 199                 /*
 200                 Mockito.when(dataSet1.getString(Mockito.anyInt(), Mockito.anyObject())).thenAnswer(new Answer<String>() {
 201
 202                         @Override
 203                         public String answer(InvocationOnMock invocation) throws Throwable {
 204                                 Object args[] = invocation.getArguments();
 205                                 int columnIndex= 0;
 206
 207                                 try {
 208                                         columnIndex = Integer.parseInt((String)args[1]);
 209                                 } catch (Exception e) {
 210                                         if ("encrypt_yn".equals((String)args[1]))
 211                                 }
 212
 213
 214                                 return null;
 215                         }
 216                 });
 217                 */
 218         }
 219
 220         private void createInstanceOfReportSchedule_case2() throws Exception {
 221                 String load_schedule_data = "SELECT rs.enabled_yn, DATE_FORMAT(rs.start_date, '%m/%d/%Y') start_date, DATE_FORMAT(rs.end_date, '%m/%d/%Y') end_date, DATE_FORMAT(rs.run_date, '%m/%d/%Y') run_date, coalesce(DATE_FORMAT(rs.run_date, '%h'), '12') run_hour, coalesce(DATE_FORMAT(rs.run_date, '%i'), '00') run_min, coalesce(DATE_FORMAT(rs.run_date, '%p'), 'AM') run_ampm, rs.recurrence, rs.conditional_yn, rs.notify_type, rs.max_row, rs.initial_formfields, rs.schedule_id, coalesce(DATE_FORMAT(rs.end_date, '%h'), '11') end_hour, coalesce(DATE_FORMAT(rs.end_date, '%i'), '45') end_min, coalesce(DATE_FORMAT(rs.end_date, '%p'), 'PM') end_ampm, encrypt_yn, attachment_yn FROM cr_report_schedule rs WHERE rs.rep_id = [reportID]";
 222                 String load_schedule_getid = "SELECT rsu.user_id, concat(fuser.last_name,', ',fuser.first_name), fuser.login_id FROM cr_report_schedule_users rsu, fn_user fuser WHERE rsu.rep_id = [reportID]  AND rsu.schedule_id = [getScheduleID()] and rsu.user_id IS NOT NULL and rsu.user_id = fuser.user_id";
 223                 String load_schedule_users = "SELECT rsu.role_id FROM cr_report_schedule_users rsu WHERE rsu.rep_id = [reportID] AND rsu.schedule_id = [getScheduleID()] AND rsu.role_id IS NOT NULL";
 224
 225                 String new_schedule_data = "select coalesce(max(schedule_id),0)+1  AS sequence from cr_report_schedule";
 226
 227                 PowerMockito.when(Globals.getLoadScheduleData()).thenReturn(load_schedule_data);
 228                 PowerMockito.when(Globals.getLoadScheduleGetId()).thenReturn(load_schedule_getid);
 229                 PowerMockito.when(Globals.getLoadScheduleUsers()).thenReturn(load_schedule_users);
 230                 PowerMockito.when(AppUtils.isAdminUser(httpServletRequest)).thenReturn(false);
 231                 PowerMockito.when(Globals.isWeblogicServer()).thenReturn(false);
 232                 PowerMockito.when(Globals.getNewScheduleData()).thenReturn(new_schedule_data);
 233                 PowerMockito.when(Globals.isPostgreSQL()).thenReturn(false);
 234
 235                 PowerMockito.when(Globals.getUseLoginIdInSchedYN()).thenReturn("Y");
 236
 237                 //reportSchedule = new ReportSchedule(REPORT_ID, USER_ID, false, httpServletRequest);
 238                 //String dataArray[] = {"Y", "10/10/2018", "10/10/2999", "01/11/2018", "9", "10", "AM", "Y", "Y", "0", "512","", "2000", "10", "30", "PM," };
 239
 240                 PowerMockito.when(DbUtils.getConnection()).thenReturn(connection);
 241
 242                 Mockito.when(connection.prepareStatement(Mockito.anyString())).thenReturn(preparedStatement);
 243                 Mockito.when(preparedStatement.executeQuery()).thenReturn(resultSet);
 244                 Mockito.when(resultSet.next()).thenReturn(true);
 245                 Mockito.when(resultSet.getClob(Mockito.anyInt())).thenReturn(clob);
 246
 247                 String source = "This is the source of my input stream";
 248                 InputStream inputStream = IOUtils.toInputStream(source, "UTF-8");
 249
 250                 Mockito.when(clob.getAsciiStream()).thenReturn(inputStream);
 251
 252                 //SI_REPORT_RUNTIME
 253                 PowerMockito.when(DbUtils.executeQuery(Mockito.anyString())).thenReturn(dataSet1);
 254                 Mockito.when(dataSet1.getRowCount()).thenReturn(0);
 255
 256                 Mockito.when(dataSet1.getString(Mockito.anyInt(), Mockito.anyInt())).thenReturn("Some Value1");
 257                 Mockito.when(dataSet1.getString(Mockito.anyInt(), Mockito.anyString())).thenReturn("Some Value2");
 258
 259                 reportSchedule = new ReportSchedule(REPORT_ID, "SCHDULE_ID", USER_ID, httpServletRequest);
 260
 261                 /*
 262                 Mockito.when(dataSet1.getString(Mockito.anyInt(), Mockito.anyObject())).thenAnswer(new Answer<String>() {
 263
 264                         @Override
 265                         public String answer(InvocationOnMock invocation) throws Throwable {
 266                                 Object args[] = invocation.getArguments();
 267                                 int columnIndex= 0;
 268
 269                                 try {
 270                                         columnIndex = Integer.parseInt((String)args[1]);
 271                                 } catch (Exception e) {
 272                                         if ("encrypt_yn".equals((String)args[1]))
 273                                 }
 274
 275
 276                                 return null;
 277                         }
 278                 });
 279                 */
 280         }
 281
 282
 283
 284         @Test
 285         public void testAddEmailToUser() {
 286                 reportSchedule.addEmailToUser("UserID1", "UserName1");
 287                 reportSchedule.addEmailToUser("UserID2", "UserName2");
 288                 reportSchedule.addEmailToUser("UserID2", "UserName2");
 289
 290         }
 291
 292         @Test
 293         public void testPersistScheduleData_case1() throws Exception {
 294                 reportSchedule.persistScheduleData(connection, httpServletRequest);
 295         }
 296
 297         @Test
 298         public void testPersistScheduleData_RowCount_case1() throws Exception {
 299                 String execute_update = "DELETE FROM cr_report_schedule_users WHERE rep_id = [reportID] and schedule_id = [getScheduleID()]";
 300                 String execute_update_users = "INSERT INTO cr_report_schedule_users (schedule_id, rep_id, user_id, role_id, order_no) VALUES([getScheduleID()], [reportID], [emailToUsers.get(i)).getId()], NULL, [(i + 1)])";
 301                 String execute_update_roles = "INSERT INTO cr_report_schedule_users (schedule_id, rep_id, user_id, role_id, order_no) VALUES([getScheduleID()], [reportID], NULL, [emailToRoles.get(i)).getId()], [((emailToUsers.size() + i + 1)])";
 302                 String execute_update_activity = "INSERT into cr_schedule_activity_log (schedule_id, notes, run_time) values ([getScheduleID()],'Submitted:Schedule',TO_DATE('[getRunDate()] [getRunHour()]:[getRunMin()] [getRunAMPM()]', 'MM/DD/YYYY HH:MI AM'))";
 303                 String persist_cond_sql_update = "update cr_report_schedule set condition_large_sql = '' where  schedule_id = [scheduleId]";
 304
 305                 PowerMockito.when(DbUtils.executeQuery(Mockito.anyObject(), Mockito.anyString())).thenReturn(dataSet1);
 306                 PowerMockito.when(Globals.getExecuteUpdate()).thenReturn(execute_update);
 307                 PowerMockito.when(Globals.getExecuteUpdateUsers()).thenReturn(execute_update_users);
 308                 PowerMockito.when(Globals.getExecuteUpdateRoles()).thenReturn(execute_update_roles);
 309                 PowerMockito.when(Globals.getExecuteUpdateActivity()).thenReturn(execute_update_activity);
 310                 PowerMockito.when(Globals.getPersistCondSqlUpdate()).thenReturn(persist_cond_sql_update);
 311                 PowerMockito.when(Globals.isPostgreSQL()).thenReturn(true);
 312
 313                 PowerMockito.when(Globals.getRequestParams()).thenReturn("1, 2, 3");
 314                 PowerMockito.when(Globals.getSessionParams()).thenReturn("1, 2, 3");
 315                 PowerMockito.when(Globals.getSessionParamsForScheduling()).thenReturn("login_id");
 316
 317                 Mockito.when(reportRuntime.getDBInfo()).thenReturn(AppConstants.DB_LOCAL);
 318
 319                 Mockito.when(connection.prepareStatement(Mockito.anyString())).thenReturn(preparedStatement);
 320                 Mockito.when(preparedStatement.executeQuery()).thenReturn(resultSet);
 321                 Mockito.when(resultSet.next()).thenReturn(true);
 322
 323                 Mockito.when(dataSet1.getRowCount()).thenReturn(1);
 324
 325                 reportSchedule.setDownloadLimit("1000");
 326                 reportSchedule.setSchedEnabled("N");
 327                 reportSchedule.setFormFields("Field1");
 328                 reportSchedule.setNotify_type("1");
 329                 reportSchedule.setStartDate("10/10/2018");
 330                 reportSchedule.setEndDate("10/10/2019");
 331                 reportSchedule.setRunDate("10/10/2019");
 332                 reportSchedule.setRunHour("10");
 333                 reportSchedule.setRunMin("10");
 334                 reportSchedule.setRunAMPM("PM");
 335                 reportSchedule.setRecurrence("Y");
 336                 reportSchedule.setAttachmentMode("N");
 337                 reportSchedule.setConditionSQL("SELECT coalesce(cr.owner_id, cr.create_id) owner_id, cr.create_id, DATE_FORMAT(cr.create_date, '[Globals.getTimeFormat()]') create_date, maint_id, DATE_FORMAT(cr.maint_date, '[Globals.getTimeFormat()]') update_date, cr.menu_id, cr.menu_approved_yn FROM cr_report cr WHERE cr.rep_id= [reportID]");
 338
 339                 reportSchedule.persistScheduleData(connection, httpServletRequest);
 340         }
 341
 342         @Test
 343         public void testPersistScheduleData_RowCount_case2() throws Exception {
 344                 String execute_update = "DELETE FROM cr_report_schedule_users WHERE rep_id = [reportID] and schedule_id = [getScheduleID()]";
 345                 String execute_update_users = "INSERT INTO cr_report_schedule_users (schedule_id, rep_id, user_id, role_id, order_no) VALUES([getScheduleID()], [reportID], [emailToUsers.get(i)).getId()], NULL, [(i + 1)])";
 346                 String execute_update_roles = "INSERT INTO cr_report_schedule_users (schedule_id, rep_id, user_id, role_id, order_no) VALUES([getScheduleID()], [reportID], NULL, [emailToRoles.get(i)).getId()], [((emailToUsers.size() + i + 1)])";
 347                 String execute_update_activity = "INSERT into cr_schedule_activity_log (schedule_id, notes, run_time) values ([getScheduleID()],'Submitted:Schedule',TO_DATE('[getRunDate()] [getRunHour()]:[getRunMin()] [getRunAMPM()]', 'MM/DD/YYYY HH:MI AM'))";
 348                 String persist_cond_sql_update = "update cr_report_schedule set condition_large_sql = '' where  schedule_id = [scheduleId]";
 349
 350                 PowerMockito.when(DbUtils.executeQuery(Mockito.anyObject(), Mockito.anyString())).thenReturn(dataSet1);
 351                 PowerMockito.when(Globals.getExecuteUpdate()).thenReturn(execute_update);
 352                 PowerMockito.when(Globals.getExecuteUpdateUsers()).thenReturn(execute_update_users);
 353                 PowerMockito.when(Globals.getExecuteUpdateRoles()).thenReturn(execute_update_roles);
 354                 PowerMockito.when(Globals.getExecuteUpdateActivity()).thenReturn(execute_update_activity);
 355                 PowerMockito.when(Globals.getPersistCondSqlUpdate()).thenReturn(persist_cond_sql_update);
 356                 PowerMockito.when(Globals.isPostgreSQL()).thenReturn(true);
 357
 358                 PowerMockito.when(Globals.getRequestParams()).thenReturn("1, 2, 3");
 359                 PowerMockito.when(Globals.getSessionParams()).thenReturn("1, 2, 3");
 360                 PowerMockito.when(Globals.getSessionParamsForScheduling()).thenReturn("login_id");
 361
 362                 Mockito.when(reportRuntime.getDBInfo()).thenReturn(AppConstants.DB_DEV);
 363
 364                 Mockito.when(connection.prepareStatement(Mockito.anyString())).thenReturn(preparedStatement);
 365                 Mockito.when(preparedStatement.executeQuery()).thenReturn(resultSet);
 366                 Mockito.when(resultSet.next()).thenReturn(true);
 367
 368                 Mockito.when(dataSet1.getRowCount()).thenReturn(0);
 369
 370                 reportSchedule.setSchedEnabled("N");
 371                 reportSchedule.setConditionSQL("SELECT coalesce(cr.owner_id, cr.create_id) owner_id, cr.create_id, DATE_FORMAT(cr.create_date, '[Globals.getTimeFormat()]') create_date, maint_id, DATE_FORMAT(cr.maint_date, '[Globals.getTimeFormat()]') update_date, cr.menu_id, cr.menu_approved_yn FROM cr_report cr WHERE cr.rep_id= [reportID]");
 372
 373                 reportSchedule.persistScheduleData(connection, httpServletRequest);
 374         }
 375
 376         @Test
 377         public void testPersistScheduleData_FormFieldList_case1() throws Exception {
 378                 String execute_update = "DELETE FROM cr_report_schedule_users WHERE rep_id = [reportID] and schedule_id = [getScheduleID()]";
 379                 String execute_update_users = "INSERT INTO cr_report_schedule_users (schedule_id, rep_id, user_id, role_id, order_no) VALUES([getScheduleID()], [reportID], [emailToUsers.get(i)).getId()], NULL, [(i + 1)])";
 380                 String execute_update_roles = "INSERT INTO cr_report_schedule_users (schedule_id, rep_id, user_id, role_id, order_no) VALUES([getScheduleID()], [reportID], NULL, [emailToRoles.get(i)).getId()], [((emailToUsers.size() + i + 1)])";
 381                 String execute_update_activity = "INSERT into cr_schedule_activity_log (schedule_id, notes, run_time) values ([getScheduleID()],'Submitted:Schedule',TO_DATE('[getRunDate()] [getRunHour()]:[getRunMin()] [getRunAMPM()]', 'MM/DD/YYYY HH:MI AM'))";
 382                 String persist_cond_sql_update = "update cr_report_schedule set condition_large_sql = '' where  schedule_id = [scheduleId]";
 383
 384                 PowerMockito.when(DbUtils.executeQuery(Mockito.anyObject(), Mockito.anyString())).thenReturn(dataSet1);
 385                 PowerMockito.when(Globals.getExecuteUpdate()).thenReturn(execute_update);
 386                 PowerMockito.when(Globals.getExecuteUpdateUsers()).thenReturn(execute_update_users);
 387                 PowerMockito.when(Globals.getExecuteUpdateRoles()).thenReturn(execute_update_roles);
 388                 PowerMockito.when(Globals.getExecuteUpdateActivity()).thenReturn(execute_update_activity);
 389                 PowerMockito.when(Globals.getPersistCondSqlUpdate()).thenReturn(persist_cond_sql_update);
 390                 PowerMockito.when(Globals.isPostgreSQL()).thenReturn(true);
 391                 PowerMockito.when(Globals.getRequestParams()).thenReturn("1, 2, 3");
 392                 PowerMockito.when(Globals.getSessionParams()).thenReturn("1, 2, 3");
 393                 PowerMockito.when(Globals.getSessionParamsForScheduling()).thenReturn("login_id");
 394
 395                 FormFieldList formFieldList = new FormFieldList();
 396                 formFieldList.setComment("test");
 397                 FormFieldType formFieldType = new FormFieldType();
 398                 formFieldType.setFieldId("test");
 399                 formFieldType.setColId("1");
 400                 formFieldType.setFieldName("test");
 401                 formFieldType.setFieldType("type");
 402                 formFieldType.setValidationType("validation");
 403                 formFieldType.setMandatory("Y");
 404                 formFieldType.setDefaultValue("test");
 405                 formFieldType.setGroupFormField(true);
 406                 formFieldList.getFormField().add(formFieldType);
 407                 Mockito.when(reportRuntime.getFormFieldList()).thenReturn(formFieldList);
 408                 Mockito.when(reportRuntime.getFormFieldDisplayName(Mockito.any(FormFieldType.class))).thenReturn("test");
 409                 ReportParamValues paramValues = PowerMockito.mock(ReportParamValues.class);
 410                 Mockito.when(paramValues.isParameterMultiValue(Matchers.anyString())).thenReturn(true);
 411                 Mockito.when(paramValues.getParamValue(Mockito.any(String.class))).thenReturn("select test");
 412                 Mockito.when(reportRuntime.getReportParamValues()).thenReturn(paramValues);
 413                 DataSet ds = Mockito.mock(DataSet.class);
 414                 Mockito.when(ConnectionUtils.getDataSet(Mockito.any(String.class), Mockito.any(String.class))).thenReturn(ds);
 415                 Mockito.when(ds.getRowCount()).thenReturn(1);
 416                 Mockito.when(ds.getString(Mockito.anyInt(), Mockito.anyInt())).thenReturn("test");
 417                 Mockito.when(reportRuntime.formatListValue(Mockito.any(String.class), Mockito.any(String.class), Mockito.any(DataColumnType.class),
 418                                 Mockito.anyBoolean(), Mockito.anyBoolean(), Mockito.any(DataSourceType.class), Mockito.any(String.class))).thenReturn("");
 419
 420                 Mockito.when(connection.prepareStatement(Mockito.anyString())).thenReturn(preparedStatement);
 421                 Mockito.when(preparedStatement.executeQuery()).thenReturn(resultSet);
 422                 Mockito.when(resultSet.next()).thenReturn(true);
 423
 424                 Mockito.when(dataSet1.getRowCount()).thenReturn(0);
 425
 426                 reportSchedule.setSchedEnabled("N");
 427                 reportSchedule.setConditionSQL("SELECT WHEN FROM TABLE WHERE  AND [test] ORDER BY");
 428
 429                 reportSchedule.persistScheduleData(connection, httpServletRequest);
 430         }
 431
 432         @Test
 433         public void testPersistScheduleData_FormFieldList_case2() throws Exception {
 434                 String execute_update = "DELETE FROM cr_report_schedule_users WHERE rep_id = [reportID] and schedule_id = [getScheduleID()]";
 435                 String execute_update_users = "INSERT INTO cr_report_schedule_users (schedule_id, rep_id, user_id, role_id, order_no) VALUES([getScheduleID()], [reportID], [emailToUsers.get(i)).getId()], NULL, [(i + 1)])";
 436                 String execute_update_roles = "INSERT INTO cr_report_schedule_users (schedule_id, rep_id, user_id, role_id, order_no) VALUES([getScheduleID()], [reportID], NULL, [emailToRoles.get(i)).getId()], [((emailToUsers.size() + i + 1)])";
 437                 String execute_update_activity = "INSERT into cr_schedule_activity_log (schedule_id, notes, run_time) values ([getScheduleID()],'Submitted:Schedule',TO_DATE('[getRunDate()] [getRunHour()]:[getRunMin()] [getRunAMPM()]', 'MM/DD/YYYY HH:MI AM'))";
 438                 String persist_cond_sql_update = "update cr_report_schedule set condition_large_sql = '' where  schedule_id = [scheduleId]";
 439
 440                 PowerMockito.when(DbUtils.executeQuery(Mockito.anyObject(), Mockito.anyString())).thenReturn(dataSet1);
 441                 PowerMockito.when(Globals.getExecuteUpdate()).thenReturn(execute_update);
 442                 PowerMockito.when(Globals.getExecuteUpdateUsers()).thenReturn(execute_update_users);
 443                 PowerMockito.when(Globals.getExecuteUpdateRoles()).thenReturn(execute_update_roles);
 444                 PowerMockito.when(Globals.getExecuteUpdateActivity()).thenReturn(execute_update_activity);
 445                 PowerMockito.when(Globals.getPersistCondSqlUpdate()).thenReturn(persist_cond_sql_update);
 446                 PowerMockito.when(Globals.isPostgreSQL()).thenReturn(true);
 447                 PowerMockito.when(Globals.getRequestParams()).thenReturn("1, 2, 3");
 448                 PowerMockito.when(Globals.getSessionParams()).thenReturn("1, 2, 3");
 449                 PowerMockito.when(Globals.getSessionParamsForScheduling()).thenReturn("login_id");
 450
 451                 FormFieldList formFieldList = new FormFieldList();
 452                 formFieldList.setComment("test");
 453                 FormFieldType formFieldType = new FormFieldType();
 454                 formFieldType.setFieldId("test");
 455                 formFieldType.setColId("1");
 456                 formFieldType.setFieldName("test");
 457                 formFieldType.setFieldType("type");
 458                 formFieldType.setValidationType("validation");
 459                 formFieldType.setMandatory("Y");
 460                 formFieldType.setDefaultValue("test");
 461                 formFieldType.setGroupFormField(true);
 462                 formFieldList.getFormField().add(formFieldType);
 463                 Mockito.when(reportRuntime.getFormFieldList()).thenReturn(formFieldList);
 464                 Mockito.when(reportRuntime.getFormFieldDisplayName(Mockito.any(FormFieldType.class))).thenReturn("test");
 465                 ReportParamValues paramValues = PowerMockito.mock(ReportParamValues.class);
 466                 Mockito.when(paramValues.isParameterMultiValue(Matchers.anyString())).thenReturn(false);
 467                 Mockito.when(paramValues.isParameterTextAreaValueAndModified(Mockito.any(String.class))).thenReturn(true);
 468                 Mockito.when(paramValues.getParamValue(Mockito.any(String.class))).thenReturn("select test");
 469                 Mockito.when(reportRuntime.getReportParamValues()).thenReturn(paramValues);
 470                 DataSet ds = Mockito.mock(DataSet.class);
 471                 Mockito.when(ConnectionUtils.getDataSet(Mockito.any(String.class), Mockito.any(String.class))).thenReturn(ds);
 472                 Mockito.when(ds.getRowCount()).thenReturn(1);
 473                 Mockito.when(ds.getString(Mockito.anyInt(), Mockito.anyInt())).thenReturn("test");
 474                 Mockito.when(reportRuntime.getDBInfo()).thenReturn(AppConstants.DB_DEV);
 475                 RemDbInfo remDbInfo = Mockito.mock(RemDbInfo.class);
 476                 PowerMockito.whenNew(RemDbInfo.class).withNoArguments().thenReturn(remDbInfo);
 477                 Mockito.when(remDbInfo.getDBType(Mockito.any(String.class))).thenReturn("DAYTONA");
 478                 Mockito.when(reportRuntime.formatListValue(Mockito.any(String.class), Mockito.any(String.class), Mockito.any(DataColumnType.class),
 479                                 Mockito.anyBoolean(), Mockito.anyBoolean(), Mockito.any(DataSourceType.class), Mockito.any(String.class))).thenReturn("test");
 480
 481                 Mockito.when(connection.prepareStatement(Mockito.anyString())).thenReturn(preparedStatement);
 482                 Mockito.when(preparedStatement.executeQuery()).thenReturn(resultSet);
 483                 Mockito.when(resultSet.next()).thenReturn(true);
 484
 485                 Mockito.when(dataSet1.getRowCount()).thenReturn(0);
 486
 487                 reportSchedule.setSchedEnabled("N");
 488                 reportSchedule.setConditionSQL("SELECT WHEN FROM TABLE WHERE [test] ORDER BY");
 489
 490                 reportSchedule.persistScheduleData(connection, httpServletRequest);
 491         }
 492
 493         @Test
 494         public void testPersistScheduleData_FormFieldList_case3() throws Exception {
 495                 String execute_update = "DELETE FROM cr_report_schedule_users WHERE rep_id = [reportID] and schedule_id = [getScheduleID()]";
 496                 String execute_update_users = "INSERT INTO cr_report_schedule_users (schedule_id, rep_id, user_id, role_id, order_no) VALUES([getScheduleID()], [reportID], [emailToUsers.get(i)).getId()], NULL, [(i + 1)])";
 497                 String execute_update_roles = "INSERT INTO cr_report_schedule_users (schedule_id, rep_id, user_id, role_id, order_no) VALUES([getScheduleID()], [reportID], NULL, [emailToRoles.get(i)).getId()], [((emailToUsers.size() + i + 1)])";
 498                 String execute_update_activity = "INSERT into cr_schedule_activity_log (schedule_id, notes, run_time) values ([getScheduleID()],'Submitted:Schedule',TO_DATE('[getRunDate()] [getRunHour()]:[getRunMin()] [getRunAMPM()]', 'MM/DD/YYYY HH:MI AM'))";
 499                 String persist_cond_sql_update = "update cr_report_schedule set condition_large_sql = '' where  schedule_id = [scheduleId]";
 500
 501                 PowerMockito.when(DbUtils.executeQuery(Mockito.anyObject(), Mockito.anyString())).thenReturn(dataSet1);
 502                 PowerMockito.when(Globals.getExecuteUpdate()).thenReturn(execute_update);
 503                 PowerMockito.when(Globals.getExecuteUpdateUsers()).thenReturn(execute_update_users);
 504                 PowerMockito.when(Globals.getExecuteUpdateRoles()).thenReturn(execute_update_roles);
 505                 PowerMockito.when(Globals.getExecuteUpdateActivity()).thenReturn(execute_update_activity);
 506                 PowerMockito.when(Globals.getPersistCondSqlUpdate()).thenReturn(persist_cond_sql_update);
 507                 PowerMockito.when(Globals.isPostgreSQL()).thenReturn(true);
 508                 PowerMockito.when(Globals.getRequestParams()).thenReturn("1, 2, 3");
 509                 PowerMockito.when(Globals.getSessionParams()).thenReturn("1, 2, 3");
 510                 PowerMockito.when(Globals.getSessionParamsForScheduling()).thenReturn("login_id");
 511
 512                 FormFieldList formFieldList = new FormFieldList();
 513                 formFieldList.setComment("test");
 514                 FormFieldType formFieldType = new FormFieldType();
 515                 formFieldType.setFieldId("test");
 516                 formFieldType.setColId("1");
 517                 formFieldType.setFieldName("test");
 518                 formFieldType.setFieldType("type");
 519                 formFieldType.setValidationType("validation");
 520                 formFieldType.setMandatory("Y");
 521                 formFieldType.setDefaultValue("test");
 522                 formFieldType.setGroupFormField(true);
 523                 formFieldType.setValidationType(FormField.VT_TIMESTAMP_MIN);
 524                 formFieldList.getFormField().add(formFieldType);
 525                 Mockito.when(reportRuntime.getFormFieldList()).thenReturn(formFieldList);
 526                 Mockito.when(reportRuntime.getFormFieldDisplayName(Mockito.any(FormFieldType.class))).thenReturn("report_id");
 527                 ReportParamValues paramValues = PowerMockito.mock(ReportParamValues.class);
 528                 Mockito.when(paramValues.isParameterMultiValue(Matchers.anyString())).thenReturn(false);
 529                 Mockito.when(paramValues.isParameterTextAreaValueAndModified(Mockito.any(String.class))).thenReturn(true);
 530                 Mockito.when(paramValues.getParamValue(Mockito.any(String.class))).thenReturn("select test");
 531                 Mockito.when(reportRuntime.getReportParamValues()).thenReturn(paramValues);
 532                 DataSet ds = Mockito.mock(DataSet.class);
 533                 Mockito.when(ConnectionUtils.getDataSet(Mockito.any(String.class), Mockito.any(String.class))).thenReturn(ds);
 534                 Mockito.when(ds.getRowCount()).thenReturn(1);
 535                 Mockito.when(ds.getString(Mockito.anyInt(), Mockito.anyInt())).thenReturn("test");
 536                 Mockito.when(reportRuntime.getDBInfo()).thenReturn(AppConstants.DB_DEV);
 537                 RemDbInfo remDbInfo = Mockito.mock(RemDbInfo.class);
 538                 PowerMockito.whenNew(RemDbInfo.class).withNoArguments().thenReturn(remDbInfo);
 539                 Mockito.when(remDbInfo.getDBType(Mockito.any(String.class))).thenReturn("DAYTONA");
 540                 Mockito.when(reportRuntime.formatListValue(Mockito.any(String.class), Mockito.any(String.class), Mockito.any(DataColumnType.class),
 541                                 Mockito.anyBoolean(), Mockito.anyBoolean(), Mockito.any(DataSourceType.class), Mockito.any(String.class))).thenReturn("test");
 542
 543                 Mockito.when(connection.prepareStatement(Mockito.anyString())).thenReturn(preparedStatement);
 544                 Mockito.when(preparedStatement.executeQuery()).thenReturn(resultSet);
 545                 Mockito.when(resultSet.next()).thenReturn(true);
 546
 547                 Mockito.when(dataSet1.getRowCount()).thenReturn(0);
 548
 549                 reportSchedule.setSchedEnabled("N");
 550                 reportSchedule.setConditionSQL("SELECT WHEN FROM TABLE WHERE [report_id] ORDER BY");
 551
 552                 reportSchedule.persistScheduleData(connection, httpServletRequest);
 553         }
 554
 555         @Test
 556         public void testPersistScheduleData_FormFieldList_case4() throws Exception {
 557                 String execute_update = "DELETE FROM cr_report_schedule_users WHERE rep_id = [reportID] and schedule_id = [getScheduleID()]";
 558                 String execute_update_users = "INSERT INTO cr_report_schedule_users (schedule_id, rep_id, user_id, role_id, order_no) VALUES([getScheduleID()], [reportID], [emailToUsers.get(i)).getId()], NULL, [(i + 1)])";
 559                 String execute_update_roles = "INSERT INTO cr_report_schedule_users (schedule_id, rep_id, user_id, role_id, order_no) VALUES([getScheduleID()], [reportID], NULL, [emailToRoles.get(i)).getId()], [((emailToUsers.size() + i + 1)])";
 560                 String execute_update_activity = "INSERT into cr_schedule_activity_log (schedule_id, notes, run_time) values ([getScheduleID()],'Submitted:Schedule',TO_DATE('[getRunDate()] [getRunHour()]:[getRunMin()] [getRunAMPM()]', 'MM/DD/YYYY HH:MI AM'))";
 561                 String persist_cond_sql_update = "update cr_report_schedule set condition_large_sql = '' where  schedule_id = [scheduleId]";
 562
 563                 PowerMockito.when(DbUtils.executeQuery(Mockito.anyObject(), Mockito.anyString())).thenReturn(dataSet1);
 564                 PowerMockito.when(Globals.getExecuteUpdate()).thenReturn(execute_update);
 565                 PowerMockito.when(Globals.getExecuteUpdateUsers()).thenReturn(execute_update_users);
 566                 PowerMockito.when(Globals.getExecuteUpdateRoles()).thenReturn(execute_update_roles);
 567                 PowerMockito.when(Globals.getExecuteUpdateActivity()).thenReturn(execute_update_activity);
 568                 PowerMockito.when(Globals.getPersistCondSqlUpdate()).thenReturn(persist_cond_sql_update);
 569                 PowerMockito.when(Globals.isPostgreSQL()).thenReturn(true);
 570                 PowerMockito.when(Globals.getRequestParams()).thenReturn("1, 2, 3");
 571                 PowerMockito.when(Globals.getSessionParams()).thenReturn("1, 2, 3");
 572                 PowerMockito.when(Globals.getSessionParamsForScheduling()).thenReturn("login_id");
 573
 574                 FormFieldList formFieldList = new FormFieldList();
 575                 formFieldList.setComment("test");
 576                 FormFieldType formFieldType = new FormFieldType();
 577                 formFieldType.setFieldId("test");
 578                 formFieldType.setColId("1");
 579                 formFieldType.setFieldName("test");
 580                 formFieldType.setFieldType("type");
 581                 formFieldType.setValidationType("validation");
 582                 formFieldType.setMandatory("Y");
 583                 formFieldType.setDefaultValue("test");
 584                 formFieldType.setGroupFormField(true);
 585                 formFieldType.setValidationType(FormField.VT_TIMESTAMP_MIN);
 586                 formFieldList.getFormField().add(formFieldType);
 587                 Mockito.when(reportRuntime.getFormFieldList()).thenReturn(formFieldList);
 588                 Mockito.when(reportRuntime.getFormFieldDisplayName(Mockito.any(FormFieldType.class))).thenReturn("report_id");
 589                 ReportParamValues paramValues = PowerMockito.mock(ReportParamValues.class);
 590                 Mockito.when(paramValues.isParameterMultiValue(Matchers.anyString())).thenReturn(false);
 591                 Mockito.when(paramValues.isParameterTextAreaValueAndModified(Mockito.any(String.class))).thenReturn(true);
 592                 Mockito.when(paramValues.getParamValue(Mockito.any(String.class))).thenReturn("select test");
 593                 Mockito.when(reportRuntime.getReportParamValues()).thenReturn(paramValues);
 594                 DataSet ds = Mockito.mock(DataSet.class);
 595                 Mockito.when(ConnectionUtils.getDataSet(Mockito.any(String.class), Mockito.any(String.class))).thenReturn(ds);
 596                 Mockito.when(ds.getRowCount()).thenReturn(1);
 597                 Mockito.when(ds.getString(Mockito.anyInt(), Mockito.anyInt())).thenReturn("test");
 598                 Mockito.when(reportRuntime.getDBInfo()).thenReturn(AppConstants.DB_DEV);
 599                 RemDbInfo remDbInfo = Mockito.mock(RemDbInfo.class);
 600                 PowerMockito.whenNew(RemDbInfo.class).withNoArguments().thenReturn(remDbInfo);
 601                 Mockito.when(remDbInfo.getDBType(Mockito.any(String.class))).thenReturn("DAYTONA");
 602                 Mockito.when(reportRuntime.formatListValue(Mockito.any(String.class), Mockito.any(String.class), Mockito.any(DataColumnType.class),
 603                                 Mockito.anyBoolean(), Mockito.anyBoolean(), Mockito.any(DataSourceType.class), Mockito.any(String.class))).thenReturn("test");
 604
 605                 Mockito.when(connection.prepareStatement(Mockito.anyString())).thenReturn(preparedStatement);
 606                 Mockito.when(preparedStatement.executeQuery()).thenReturn(resultSet);
 607                 Mockito.when(resultSet.next()).thenReturn(true);
 608
 609                 Mockito.when(dataSet1.getRowCount()).thenReturn(0);
 610
 611                 reportSchedule.setSchedEnabled("N");
 612                 reportSchedule.setConditionSQL("SELECT WHEN FROM TABLE WHERE [report_id] ORDER BY");
 613
 614                 reportSchedule.persistScheduleData(connection, httpServletRequest);
 615         }
 616
 617         @Test
 618         public void testPersistScheduleData_FormFieldList_case5() throws Exception {
 619                 String execute_update = "DELETE FROM cr_report_schedule_users WHERE rep_id = [reportID] and schedule_id = [getScheduleID()]";
 620                 String execute_update_users = "INSERT INTO cr_report_schedule_users (schedule_id, rep_id, user_id, role_id, order_no) VALUES([getScheduleID()], [reportID], [emailToUsers.get(i)).getId()], NULL, [(i + 1)])";
 621                 String execute_update_roles = "INSERT INTO cr_report_schedule_users (schedule_id, rep_id, user_id, role_id, order_no) VALUES([getScheduleID()], [reportID], NULL, [emailToRoles.get(i)).getId()], [((emailToUsers.size() + i + 1)])";
 622                 String execute_update_activity = "INSERT into cr_schedule_activity_log (schedule_id, notes, run_time) values ([getScheduleID()],'Submitted:Schedule',TO_DATE('[getRunDate()] [getRunHour()]:[getRunMin()] [getRunAMPM()]', 'MM/DD/YYYY HH:MI AM'))";
 623                 String persist_cond_sql_update = "update cr_report_schedule set condition_large_sql = '' where  schedule_id = [scheduleId]";
 624
 625                 PowerMockito.when(DbUtils.executeQuery(Mockito.anyObject(), Mockito.anyString())).thenReturn(dataSet1);
 626                 PowerMockito.when(Globals.getExecuteUpdate()).thenReturn(execute_update);
 627                 PowerMockito.when(Globals.getExecuteUpdateUsers()).thenReturn(execute_update_users);
 628                 PowerMockito.when(Globals.getExecuteUpdateRoles()).thenReturn(execute_update_roles);
 629                 PowerMockito.when(Globals.getExecuteUpdateActivity()).thenReturn(execute_update_activity);
 630                 PowerMockito.when(Globals.getPersistCondSqlUpdate()).thenReturn(persist_cond_sql_update);
 631                 PowerMockito.when(Globals.isPostgreSQL()).thenReturn(true);
 632                 PowerMockito.when(Globals.getRequestParams()).thenReturn("1, 2, 3");
 633                 PowerMockito.when(Globals.getSessionParams()).thenReturn("1, 2, 3");
 634                 PowerMockito.when(Globals.getSessionParamsForScheduling()).thenReturn("login_id");
 635
 636                 FormFieldList formFieldList = new FormFieldList();
 637                 formFieldList.setComment("test");
 638                 FormFieldType formFieldType = new FormFieldType();
 639                 formFieldType.setFieldId("test");
 640                 formFieldType.setColId("1");
 641                 formFieldType.setFieldName("test");
 642                 formFieldType.setFieldType("type");
 643                 formFieldType.setValidationType("validation");
 644                 formFieldType.setMandatory("Y");
 645                 formFieldType.setDefaultValue("test");
 646                 formFieldType.setGroupFormField(true);
 647                 formFieldType.setValidationType(FormField.VT_TIMESTAMP_SEC);
 648                 formFieldList.getFormField().add(formFieldType);
 649                 Mockito.when(reportRuntime.getFormFieldList()).thenReturn(formFieldList);
 650                 Mockito.when(reportRuntime.getFormFieldDisplayName(Mockito.any(FormFieldType.class))).thenReturn("report_id");
 651                 ReportParamValues paramValues = PowerMockito.mock(ReportParamValues.class);
 652                 Mockito.when(paramValues.isParameterMultiValue(Matchers.anyString())).thenReturn(false);
 653                 Mockito.when(paramValues.isParameterTextAreaValueAndModified(Mockito.any(String.class))).thenReturn(true);
 654                 Mockito.when(paramValues.getParamValue(Mockito.any(String.class))).thenReturn("select test");
 655                 Mockito.when(reportRuntime.getReportParamValues()).thenReturn(paramValues);
 656                 DataSet ds = Mockito.mock(DataSet.class);
 657                 Mockito.when(ConnectionUtils.getDataSet(Mockito.any(String.class), Mockito.any(String.class))).thenReturn(ds);
 658                 Mockito.when(ds.getRowCount()).thenReturn(1);
 659                 Mockito.when(ds.getString(Mockito.anyInt(), Mockito.anyInt())).thenReturn("test");
 660                 Mockito.when(reportRuntime.getDBInfo()).thenReturn(AppConstants.DB_DEV);
 661                 RemDbInfo remDbInfo = Mockito.mock(RemDbInfo.class);
 662                 PowerMockito.whenNew(RemDbInfo.class).withNoArguments().thenReturn(remDbInfo);
 663                 Mockito.when(remDbInfo.getDBType(Mockito.any(String.class))).thenReturn("TESTDB");
 664                 Mockito.when(reportRuntime.formatListValue(Mockito.any(String.class), Mockito.any(String.class), Mockito.any(DataColumnType.class),
 665                                 Mockito.anyBoolean(), Mockito.anyBoolean(), Mockito.any(DataSourceType.class), Mockito.any(String.class))).thenReturn("test");
 666
 667                 Mockito.when(connection.prepareStatement(Mockito.anyString())).thenReturn(preparedStatement);
 668                 Mockito.when(preparedStatement.executeQuery()).thenReturn(resultSet);
 669                 Mockito.when(resultSet.next()).thenReturn(true);
 670
 671                 Mockito.when(dataSet1.getRowCount()).thenReturn(0);
 672
 673                 reportSchedule.setSchedEnabled("N");
 674                 reportSchedule.setConditionSQL("SELECT WHEN FROM TABLE WHERE [test] ORDER BY");
 675
 676                 reportSchedule.persistScheduleData(connection, httpServletRequest);
 677         }
 678
 679
 680         @Test
 681         public void testPersistScheduleData_WithRaptorException() throws Exception {
 682                 String execute_update = "DELETE FROM cr_report_schedule_users WHERE rep_id = [reportID] and schedule_id = [getScheduleID()]";
 683                 String execute_update_users = "INSERT INTO cr_report_schedule_users (schedule_id, rep_id, user_id, role_id, order_no) VALUES([getScheduleID()], [reportID], [emailToUsers.get(i)).getId()], NULL, [(i + 1)])";
 684                 String execute_update_roles = "INSERT INTO cr_report_schedule_users (schedule_id, rep_id, user_id, role_id, order_no) VALUES([getScheduleID()], [reportID], NULL, [emailToRoles.get(i)).getId()], [((emailToUsers.size() + i + 1)])";
 685                 String execute_update_activity = "INSERT into cr_schedule_activity_log (schedule_id, notes, run_time) values ([getScheduleID()],'Submitted:Schedule',TO_DATE('[getRunDate()] [getRunHour()]:[getRunMin()] [getRunAMPM()]', 'MM/DD/YYYY HH:MI AM'))";
 686                 String persist_cond_sql_update = "update cr_report_schedule set condition_large_sql = '' where  schedule_id = [scheduleId]";
 687                 String new_schedule_data = "select coalesce(max(schedule_id),0)+1  AS sequence from cr_report_schedule";
 688                 String persist_cond_sql_set = "update cr_report_schedule set condition_sql = ? where schedule_id = [scheduleId]";
 689
 690                 PowerMockito.when(DbUtils.executeQuery(Mockito.anyObject(), Mockito.anyString())).thenReturn(dataSet1);
 691                 PowerMockito.when(Globals.getExecuteUpdate()).thenReturn(execute_update);
 692                 PowerMockito.when(Globals.getExecuteUpdateUsers()).thenReturn(execute_update_users);
 693                 PowerMockito.when(Globals.getExecuteUpdateRoles()).thenReturn(execute_update_roles);
 694                 PowerMockito.when(Globals.getExecuteUpdateActivity()).thenReturn(execute_update_activity);
 695                 PowerMockito.when(Globals.getPersistCondSqlUpdate()).thenReturn(persist_cond_sql_update);
 696                 PowerMockito.when(Globals.isPostgreSQL()).thenReturn(true);
 697                 PowerMockito.when(Globals.getPersistCondSqlSet()).thenReturn(persist_cond_sql_update);
 698
 699                 PowerMockito.when(Globals.getRequestParams()).thenReturn("1, 2, 3");
 700                 PowerMockito.when(Globals.getSessionParams()).thenReturn("1, 2, 3");
 701                 PowerMockito.when(Globals.getSessionParamsForScheduling()).thenReturn("login_id");
 702                 PowerMockito.when(Globals.getNewScheduleData()).thenReturn(new_schedule_data);
 703                 Mockito.when(reportRuntime.getDBInfo()).thenReturn(AppConstants.DB_DEV);
 704
 705                 Mockito.when(connection.prepareStatement(Mockito.anyString())).thenReturn(preparedStatement);
 706                 Mockito.when(preparedStatement.executeUpdate()).thenReturn(1);
 707                 Mockito.when(resultSet.next()).thenReturn(false);
 708                 Mockito.when(dataSet1.getRowCount()).thenReturn(0);
 709
 710
 711                 reportSchedule.setSchedEnabled("N");
 712                 reportSchedule.setStartDate("10/10/2018");
 713                 reportSchedule.setEndDate("10/10/2019");
 714                 reportSchedule.setRunDate("10/10/2019");
 715                 reportSchedule.setRecurrence("Y");
 716                 reportSchedule.addEmailToUser("UserID1", "UserName1");
 717                 reportSchedule.addEmailToRole("roleId1", "roleName1");
 718                 reportSchedule.setConditionSQL("SELECT coalesce(cr.owner_id, cr.create_id) owner_id, cr.create_id, DATE_FORMAT(cr.create_date, '[Globals.getTimeFormat()]') create_date, maint_id, DATE_FORMAT(cr.maint_date, '[Globals.getTimeFormat()]') update_date, cr.menu_id, cr.menu_approved_yn FROM cr_report cr WHERE cr.rep_id= [reportID]");
 719
 720                 reportSchedule.persistScheduleData(connection, httpServletRequest);
 721         }
 722
 723
 724         @Test
 725         public void testDeleteScheduleData_case1() throws RaptorException {
 726                 String delete_schedule_data = "SELECT 1 FROM cr_report_schedule WHERE rep_id = [reportID] and sched_user_id = [getScheduleUserID()] and schedule_id = [getScheduleID()]";
 727                 String delete_schedule_data_users = "DELETE FROM cr_report_schedule_users WHERE rep_id = [reportID]  and schedule_id = [getScheduleID()]";
 728                 String delete_schedule_data_id = "DELETE FROM cr_report_schedule where rep_id = [reportID] and sched_user_id = [getScheduleUserID()] and schedule_id = [getScheduleID()]";
 729
 730                 PowerMockito.when(Globals.getDeleteScheduleData()).thenReturn(delete_schedule_data);
 731                 PowerMockito.when(Globals.getDeleteScheduleDataUsers()).thenReturn(delete_schedule_data_users);
 732                 PowerMockito.when(DbUtils.executeQuery(Mockito.anyObject(), Mockito.anyString())).thenReturn(dataSet1);
 733                 PowerMockito.when(Globals.getDeleteScheduleDataId()).thenReturn(delete_schedule_data_id);
 734
 735                 Mockito.when(dataSet1.getRowCount()).thenReturn(1);
 736
 737                 reportSchedule.deleteScheduleData(connection);
 738         }
 739
 740         @Test
 741         public void testDeleteScheduleData_case2() throws RaptorException {
 742                 String delete_schedule_data = "SELECT 1 FROM cr_report_schedule WHERE rep_id = [reportID] and sched_user_id = [getScheduleUserID()] and schedule_id = [getScheduleID()]";
 743                 String delete_schedule_data_users = "DELETE FROM cr_report_schedule_users WHERE rep_id = [reportID]  and schedule_id = [getScheduleID()]";
 744                 String delete_schedule_data_id = "DELETE FROM cr_report_schedule where rep_id = [reportID] and sched_user_id = [getScheduleUserID()] and schedule_id = [getScheduleID()]";
 745
 746                 PowerMockito.when(Globals.getDeleteScheduleData()).thenReturn(delete_schedule_data);
 747                 PowerMockito.when(Globals.getDeleteScheduleDataUsers()).thenReturn(delete_schedule_data_users);
 748                 PowerMockito.when(DbUtils.executeQuery(Mockito.anyObject(), Mockito.anyString())).thenReturn(dataSet1);
 749                 PowerMockito.when(Globals.getDeleteScheduleDataId()).thenReturn(delete_schedule_data_id);
 750
 751                 Mockito.when(dataSet1.getRowCount()).thenReturn(0);
 752
 753                 reportSchedule.deleteScheduleData(connection);
 754         }
 755
 756         @Test(expected=RaptorException.class)
 757         public void testDeleteScheduleData_case3() throws RaptorException {
 758                 String delete_schedule_data = "SELECT 1 FROM cr_report_schedule WHERE rep_id = [reportID] and sched_user_id = [getScheduleUserID()] and schedule_id = [getScheduleID()]";
 759
 760                 PowerMockito.when(Globals.getDeleteScheduleData()).thenReturn(delete_schedule_data);
 761                 PowerMockito.when(DbUtils.startTransaction()).thenReturn(null);
 762                 PowerMockito.when(DbUtils.executeQuery(Mockito.anyObject(), Mockito.anyString())).thenReturn(dataSet1);
 763
 764                 PowerMockito.doThrow(new ReportSQLException("Failed to save data...")).when(DbUtils.class);
 765                 DbUtils.commitTransaction(Mockito.anyObject());
 766
 767                 Mockito.when(dataSet1.getRowCount()).thenReturn(0);
 768
 769                 reportSchedule.deleteScheduleData(null);
 770         }
 771
 772         @Test
 773         public void testDeleteScheduleData_case4() throws RaptorException {
 774                 reportSchedule.setReportID("-1");
 775                 reportSchedule.deleteScheduleData(null);
 776         }
 777
 778
 779         @Test(expected=RuntimeException.class)
 780         public void testLoadConditionalSQL_Error_case1() throws Exception {
 781                 String load_cond_sql = "SELECT condition_large_sql FROM cr_report_schedule WHERE schedule_id=?";
 782
 783                 Mockito.when(DbUtils.getConnection()).thenReturn(connection);
 784                 Mockito.when(connection.prepareStatement(Mockito.anyString())).thenReturn(preparedStatement);
 785                 Mockito.when(preparedStatement.executeQuery()).thenReturn(resultSet);
 786                 PowerMockito.when(Globals.isWeblogicServer()).thenReturn(true);
 787                 Mockito.when(resultSet.next()).thenReturn(false);
 788
 789                 PowerMockito.when(Globals.getLoadCondSql()).thenReturn(load_cond_sql);
 790
 791                 ReportSchedule.loadConditionalSQL("scheduleId#123");
 792         }
 793
 794
 795         @Test(expected=RaptorException.class)
 796         public void testLoadConditionalSQL_Error_case2() throws Exception {
 797                 String load_cond_sql = "SELECT condition_large_sql FROM cr_report_schedule WHERE schedule_id=?";
 798                 Mockito.when(DbUtils.getConnection()).thenReturn(connection);
 799                 Mockito.when(connection.prepareStatement(Mockito.anyString())).thenReturn(preparedStatement);
 800                 Mockito.when(preparedStatement.executeQuery()).thenReturn(resultSet);
 801                 Mockito.when(Globals.isWeblogicServer()).thenReturn(false);
 802                 Mockito.when(Globals.isPostgreSQL()).thenReturn(false);
 803                 Mockito.when(Globals.isMySQL()).thenReturn(true);
 804
 805                 Mockito.when(resultSet.next()).thenReturn(false);
 806
 807                 PowerMockito.when(Globals.getLoadCondSql()).thenReturn(load_cond_sql);
 808
 809                 ReportSchedule.loadConditionalSQL("scheduleId#123");
 810         }
 811
 812         @Test
 813         public void testLoadConditionalSQL_Error_case3() throws Exception {
 814                 String load_cond_sql = "SELECT condition_large_sql FROM cr_report_schedule WHERE schedule_id=?";
 815                 Mockito.when(DbUtils.getConnection()).thenReturn(connection);
 816                 Mockito.when(connection.prepareStatement(Mockito.anyString())).thenReturn(preparedStatement);
 817                 Mockito.when(preparedStatement.executeQuery()).thenReturn(resultSet);
 818                 Mockito.when(Globals.isWeblogicServer()).thenReturn(false);
 819                 Mockito.when(Globals.isPostgreSQL()).thenReturn(false);
 820                 Mockito.when(Globals.isMySQL()).thenReturn(true);
 821
 822                 Mockito.when(resultSet.next()).thenReturn(true);
 823                 Mockito.when(resultSet.getString(1)).thenThrow(new SQLException());
 824                 PowerMockito.when(Globals.getLoadCondSql()).thenReturn(load_cond_sql);
 825
 826                 ReportSchedule.loadConditionalSQL("scheduleId#123");
 827         }
 828
 829
 830         @Test
 831         public void testAddEmailArrayToUser() {
 832                 ArrayList<IdNameValue> allSelectedUsers= new ArrayList<>();
 833                 IdNameValue idNameValue = new IdNameValue();
 834                 idNameValue.setId("1");
 835                 idNameValue.setName("test");
 836                 idNameValue.setReadOnly(true);
 837                 idNameValue.setDefaultValue(true);
 838                 allSelectedUsers.add(idNameValue);
 839                 reportSchedule.addEmailArrayToUser(allSelectedUsers);
 840                 assertEquals("1",((IdNameValue)reportSchedule.getEmailToUsers().get(0)).getId());
 841         }
 842
 843         @Test
 844         public void testRemoveEmailToUser() {
 845                 reportSchedule.removeEmailToUser("1");
 846                 List value=reportSchedule.getEmailToUsers();
 847                 boolean removed=value.contains(value);
 848                 assertFalse(removed);
 849         }
 850
 851
 852         @Test
 853         public void testAddEmailArrayToRole() {
 854                 ArrayList<IdNameValue> allSelectedUsers= new ArrayList<>();
 855                 IdNameValue idNameValue = new IdNameValue();
 856                 idNameValue.setId("roleID1");
 857                 idNameValue.setName("roleName1");
 858                 idNameValue.setReadOnly(true);
 859                 idNameValue.setDefaultValue(true);
 860                 allSelectedUsers.add(idNameValue);
 861                 reportSchedule.addEmailArrayToRole(allSelectedUsers);
 862                 assertEquals("roleID1",((IdNameValue)reportSchedule.getEmailToRoles().get(0)).getId());
 863         }
 864
 865         @Test
 866         public void testRemoveEmailToRole() {
 867                 reportSchedule.removeEmailToRole("roleID1");
 868                 List value=reportSchedule.getEmailToRoles();
 869                 boolean removed=value.contains(value);
 870                 assertFalse(removed);
 871         }
 872
 873         @Test
 874         public void testIsAttachmentMode() {
 875                 reportSchedule.setAttachmentMode("Y");
 876                 assertTrue(reportSchedule.isAttachmentMode());
 877         }
 878
 879
 880         @Test
 881         public void testSetConditional() {
 882                 reportSchedule.setConditional("Y");
 883                 assertEquals("Y",reportSchedule.getConditional());
 884         }
 885
 886 }