ONAP-REST/src/test/java/org/onap/policy/rest/daoimpl/PolicyValidationDaoImplTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP-REST
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * Modifications copyright (c) 2019 Nokia
   7  * Modifications Copyright (C) 2019 Nordix Foundation.
   8  * ================================================================================
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file 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  * ============LICENSE_END=========================================================
  21  */
  22
  23 package org.onap.policy.rest.daoimpl;
  24
  25 import static org.junit.Assert.assertEquals;
  26 import static org.junit.Assert.assertFalse;
  27 import static org.junit.Assert.assertNotEquals;
  28 import static org.junit.Assert.assertNotNull;
  29 import static org.junit.Assert.assertNull;
  30 import static org.junit.Assert.assertTrue;
  31 import static org.junit.Assert.fail;
  32
  33 import java.io.File;
  34 import java.sql.SQLException;
  35 import java.util.ArrayList;
  36 import java.util.Date;
  37 import java.util.List;
  38 import java.util.Properties;
  39
  40 import javax.script.SimpleBindings;
  41
  42 import org.apache.tomcat.dbcp.dbcp2.BasicDataSource;
  43 import org.h2.tools.Server;
  44 import org.hibernate.Query;
  45 import org.hibernate.Session;
  46 import org.hibernate.SessionFactory;
  47 import org.hibernate.Transaction;
  48 import org.junit.After;
  49 import org.junit.AfterClass;
  50 import org.junit.BeforeClass;
  51 import org.junit.Test;
  52 import org.onap.policy.common.logging.flexlogger.FlexLogger;
  53 import org.onap.policy.common.logging.flexlogger.Logger;
  54 import org.onap.policy.rest.jpa.OnapName;
  55 import org.onap.policy.rest.jpa.PolicyEntity;
  56 import org.onap.policy.rest.jpa.PolicyRoles;
  57 import org.onap.policy.rest.jpa.PolicyVersion;
  58 import org.onap.policy.rest.jpa.SystemLogDb;
  59 import org.onap.policy.rest.jpa.UserInfo;
  60 import org.onap.policy.rest.jpa.WatchPolicyNotificationTable;
  61 import org.springframework.orm.hibernate4.LocalSessionFactoryBuilder;
  62 import org.springframework.test.annotation.Rollback;
  63 import org.springframework.transaction.annotation.Transactional;
  64
  65 public class PolicyValidationDaoImplTest {
  66
  67     private static Logger logger = FlexLogger.getLogger(PolicyValidationDaoImplTest.class);
  68
  69     static SessionFactory sessionFactory;
  70     static Server server;
  71     static PolicyValidationDaoImpl commonClassDao;
  72
  73     /**
  74      * Set up all unit tests.
  75      *
  76      * @throws SQLException on SQL exceptions
  77      */
  78     @BeforeClass
  79     public static void setupAll() throws SQLException {
  80         BasicDataSource dataSource = new BasicDataSource();
  81         dataSource.setDriverClassName("org.h2.Driver");
  82         // In-memory DB for testing
  83         dataSource.setUrl("jdbc:h2:mem:test");
  84         dataSource.setUsername("sa");
  85         dataSource.setPassword("");
  86         LocalSessionFactoryBuilder sessionBuilder = new LocalSessionFactoryBuilder(dataSource);
  87         sessionBuilder.scanPackages("org.onap.*", "com.*");
  88
  89         Properties properties = new Properties();
  90         properties.put("hibernate.show_sql", "false");
  91         properties.put("hibernate.dialect", "org.hibernate.dialect.H2Dialect");
  92         properties.put("hibernate.hbm2ddl.auto", "drop");
  93         properties.put("hibernate.hbm2ddl.auto", "create");
  94
  95         sessionBuilder.addProperties(properties);
  96         sessionFactory = sessionBuilder.buildSessionFactory();
  97
  98         // Set up dao with SessionFactory
  99         commonClassDao = new PolicyValidationDaoImpl();
 100         PolicyValidationDaoImpl.setSessionfactory(sessionFactory);
 101         // PolicyController.setLogTableLimit("1");
 102         // HibernateSession.setSession(sessionFactory);
 103         SystemLogDb data1 = new SystemLogDb();
 104         data1.setDate(new Date());
 105         data1.setLogtype("INFO");
 106         data1.setRemote("Test");
 107         data1.setSystem("Test");
 108         data1.setType("Test");
 109         SystemLogDb data2 = new SystemLogDb();
 110         data2.setDate(new Date());
 111         data2.setLogtype("error");
 112         data2.setRemote("Test");
 113         data2.setSystem("Test");
 114         data2.setType("Test");
 115
 116         // Create TCP server for troubleshooting
 117         server = Server.createTcpServer("-tcpAllowOthers").start();
 118         System.out.println("URL: jdbc:h2:" + server.getURL() + "/mem:test");
 119     }
 120
 121     @AfterClass
 122     public static void deleteDB() {
 123         sessionFactory.close();
 124         server.stop();
 125     }
 126
 127     @After
 128     public void tearDown() {
 129         truncateAllTables();
 130     }
 131
 132     @Test
 133     @Transactional
 134     @Rollback(true)
 135     public void testDB() {
 136         // Add data
 137         UserInfo userinfo = new UserInfo();
 138         userinfo.setUserLoginId("Test");
 139         userinfo.setUserName("Test");
 140         commonClassDao.save(userinfo);
 141         OnapName onapName = new OnapName();
 142         onapName.setName("Test");
 143         onapName.setUserCreatedBy(userinfo);
 144         onapName.setUserModifiedBy(userinfo);
 145         onapName.setModifiedDate(new Date());
 146         commonClassDao.save(onapName);
 147
 148         List<Object> list = commonClassDao.getData(OnapName.class);
 149         assertTrue(list.size() == 1);
 150         logger.debug(list.size());
 151         logger.debug(list.get(0));
 152     }
 153
 154     @Test
 155     @Transactional
 156     @Rollback(true)
 157     public void testUser() {
 158         // Add data
 159         UserInfo userinfo = new UserInfo();
 160         String loginIdUserName = "Test";
 161         userinfo.setUserLoginId(loginIdUserName);
 162         userinfo.setUserName(loginIdUserName);
 163         commonClassDao.save(userinfo);
 164
 165         List<Object> dataCur = commonClassDao.getDataByQuery("from UserInfo", new SimpleBindings());
 166
 167         assertEquals(1, dataCur.size());
 168         UserInfo cur = (UserInfo) dataCur.get(0);
 169         assertEquals(loginIdUserName, cur.getUserLoginId());
 170         assertEquals(loginIdUserName, cur.getUserName());
 171
 172         assertFalse(dataCur.isEmpty());
 173     }
 174
 175     @Test
 176     @Transactional
 177     @Rollback(true)
 178     public void getDataByQuery_DashboardController() {
 179         // Add data
 180         PolicyEntity pe = new PolicyEntity();
 181         String name = "TestPolicy";
 182         pe.setPolicyName(name);
 183         pe.setPolicyData("dummyData");
 184         pe.prePersist();
 185         pe.setScope("dummyScope");
 186         pe.setDescription("descr");
 187         pe.setDeleted(false);
 188         pe.setCreatedBy("Test");
 189         commonClassDao.save(pe);
 190
 191         List<Object> dataCur = commonClassDao.getDataByQuery("from PolicyEntity", new SimpleBindings());
 192
 193         assertTrue(1 == dataCur.size());
 194         assertTrue(dataCur.get(0) instanceof PolicyEntity);
 195         assertEquals(name, ((PolicyEntity) dataCur.get(0)).getPolicyName());
 196         assertEquals(pe, (dataCur.get(0)));
 197     }
 198
 199     @Test
 200     @Transactional
 201     @Rollback(true)
 202     public void getDataByQuery_AutoPushController() {
 203         // Add data
 204         PolicyVersion pv = new PolicyVersion();
 205         pv.setActiveVersion(2);
 206         pv.setPolicyName("myPname");
 207         pv.prePersist();
 208         pv.setCreatedBy("Test");
 209         pv.setModifiedBy("Test");
 210
 211         PolicyVersion pv2 = new PolicyVersion();
 212         pv2.setActiveVersion(1);
 213         pv2.setPolicyName("test");
 214         pv2.prePersist();
 215         pv2.setCreatedBy("Test");
 216         pv2.setModifiedBy("Test");
 217
 218         commonClassDao.save(pv);
 219         commonClassDao.save(pv2);
 220
 221         String scope = "my";
 222         scope += "%";
 223         String query = "From PolicyVersion where policy_name like :scope and id > 0";
 224         SimpleBindings params = new SimpleBindings();
 225         params.put("scope", scope);
 226         List<Object> dataCur = commonClassDao.getDataByQuery(query, params);
 227
 228         assertTrue(1 == dataCur.size());
 229         assertEquals(pv, dataCur.get(0));
 230     }
 231
 232     @Test
 233     @Transactional
 234     @Rollback(true)
 235     public void getDataByQuery_PolicyNotificationMail() {
 236         // Add data
 237         WatchPolicyNotificationTable watch = new WatchPolicyNotificationTable();
 238         watch.setLoginIds("Test");
 239
 240         // Add data
 241         UserInfo userinfo = new UserInfo();
 242         String loginIdUserName = "Test";
 243         userinfo.setUserLoginId(loginIdUserName);
 244         userinfo.setUserName(loginIdUserName);
 245         commonClassDao.save(userinfo);
 246
 247         List<Object> dataCur = commonClassDao.getDataByQuery("from UserInfo", new SimpleBindings());
 248
 249         assertEquals(1, dataCur.size());
 250         UserInfo cur = (UserInfo) dataCur.get(0);
 251         assertEquals(loginIdUserName, cur.getUserLoginId());
 252         assertEquals(loginIdUserName, cur.getUserName());
 253
 254         assertFalse(dataCur.isEmpty());
 255
 256         watch.setPolicyName("bananaWatch");
 257         commonClassDao.save(watch);
 258
 259         String policyFileName = "banana";
 260         if (policyFileName.contains("/")) {
 261             policyFileName = policyFileName.substring(0, policyFileName.indexOf("/"));
 262             policyFileName = policyFileName.replace("/", File.separator);
 263         }
 264         if (policyFileName.contains("\\")) {
 265             policyFileName = policyFileName.substring(0, policyFileName.indexOf("\\"));
 266             policyFileName = policyFileName.replace("\\", "\\\\");
 267         }
 268
 269         // Current Implementation
 270         policyFileName += "%";
 271         String query = "from WatchPolicyNotificationTable where policyName like:policyFileName";
 272         SimpleBindings params = new SimpleBindings();
 273         params.put("policyFileName", policyFileName);
 274         dataCur = commonClassDao.getDataByQuery(query, params);
 275
 276         // Assertions
 277         assertTrue(dataCur.size() == 1);
 278         assertTrue(dataCur.get(0) instanceof WatchPolicyNotificationTable);
 279         assertEquals(watch, dataCur.get(0));
 280     }
 281
 282     @Test
 283     @Transactional
 284     @Rollback(true)
 285     public void getDataByQuery_PolicyController() {
 286         // Add data
 287         PolicyEntity pe = new PolicyEntity();
 288         String name = "actionDummy";
 289         pe.setPolicyName(name);
 290         pe.setPolicyData("dummyData");
 291         pe.prePersist();
 292         pe.setScope("dummyScope");
 293         pe.setDescription("descr");
 294         pe.setDeleted(false);
 295         pe.setCreatedBy("Test");
 296         commonClassDao.save(pe);
 297
 298         String dbCheckName = "dummyScope:action";
 299         String[] splitDbCheckName = dbCheckName.split(":");
 300
 301         // Current Implementation
 302         String query = "FROM PolicyEntity where policyName like :splitDBCheckName1 and scope = :splitDBCheckName0";
 303         SimpleBindings params = new SimpleBindings();
 304         params.put("splitDBCheckName1", splitDbCheckName[1] + "%");
 305         params.put("splitDBCheckName0", splitDbCheckName[0]);
 306         List<Object> dataCur = commonClassDao.getDataByQuery(query, params);
 307
 308         // Assertions
 309         assertTrue(dataCur.size() == 1);
 310         assertTrue(dataCur.get(0) instanceof PolicyEntity);
 311         assertEquals(pe, dataCur.get(0));
 312     }
 313
 314     @Test
 315     @Transactional
 316     @Rollback(true)
 317     public void getDataByQuery_PolicyNotificationController() {
 318         // Add data
 319         WatchPolicyNotificationTable watch = new WatchPolicyNotificationTable();
 320         String finalName = "banana"; // Policy File Name
 321         String userId = "Test";
 322         watch.setLoginIds(userId);
 323         watch.setPolicyName(finalName);
 324         commonClassDao.save(watch);
 325
 326         // Current Implementation
 327         String query = "from WatchPolicyNotificationTable where POLICYNAME = :finalName and LOGINIDS = :userId";
 328         SimpleBindings params = new SimpleBindings();
 329         params.put("finalName", finalName);
 330         params.put("userId", userId);
 331         List<Object> dataCur = commonClassDao.getDataByQuery(query, params);
 332
 333         // Assertions
 334         assertTrue(dataCur.size() == 1);
 335         assertTrue(dataCur.get(0) instanceof WatchPolicyNotificationTable);
 336         assertEquals(watch, dataCur.get(0));
 337
 338         WatchPolicyNotificationTable table0 = new WatchPolicyNotificationTable();
 339         WatchPolicyNotificationTable table1 = new WatchPolicyNotificationTable();
 340         assertEquals(table0, table0);
 341         assertEquals(table0, table1);
 342         assertNotEquals(table0, null);
 343         String helloString = "Hello";
 344         Object helloObject = helloString;
 345         assertNotEquals(table0, helloObject);
 346
 347         table0.setId(1);
 348         assertNotEquals(table0, table1);
 349         table1.setId(1);
 350         assertEquals(table0, table1);
 351
 352         table0.setPolicyName("GoToOz");
 353         assertNotEquals(table0, table1);
 354         table1.setPolicyName("GoToOz");
 355         assertEquals(table0, table1);
 356         table1.setPolicyName(null);
 357         assertNotEquals(table0, table1);
 358         table0.setPolicyName(null);
 359         assertEquals(table0, table1);
 360         table1.setPolicyName("GoToOz");
 361         assertNotEquals(table0, table1);
 362         table0.setPolicyName("GoToOz");
 363         assertEquals(table0, table1);
 364         assertEquals(table0, table1);
 365         table1.setPolicyName("InOz");
 366         assertNotEquals(table0, table1);
 367         table0.setPolicyName("InOz");
 368         assertEquals(table0, table1);
 369
 370         table0.setLoginIds("Wizard");
 371         assertNotEquals(table0, table1);
 372         table1.setLoginIds("Wizard");
 373         assertEquals(table0, table1);
 374         table1.setLoginIds(null);
 375         assertNotEquals(table0, table1);
 376         table0.setLoginIds(null);
 377         assertEquals(table0, table1);
 378         table0.setLoginIds("Wizard");
 379         assertNotEquals(table0, table1);
 380         table1.setLoginIds("Wizard");
 381         assertEquals(table0, table1);
 382         table1.setLoginIds(null);
 383         table1.setLoginIds("Witch");
 384         assertNotEquals(table0, table1);
 385         table0.setLoginIds("Witch");
 386         assertEquals(table0, table1);
 387
 388         assertNotNull(table0.hashCode());
 389         assertNotNull(table1.hashCode());
 390         assertEquals(table0.hashCode(), table0.hashCode());
 391
 392         table0.setLoginIds("Witci");
 393         assertNotEquals(table0, table1);
 394         assertNotEquals(table0.hashCode(), table1.hashCode());
 395     }
 396
 397     /*
 398      * Test for SQL Injection Protection
 399      */
 400
 401     @Test
 402     @Transactional
 403     @Rollback(true)
 404     public void getDataByQuery_PolicyNotificationController_Injection() {
 405         // Add data
 406         WatchPolicyNotificationTable watch = new WatchPolicyNotificationTable();
 407         String userId = "Test";
 408         watch.setLoginIds(userId);
 409         watch.setPolicyName("banana");
 410         commonClassDao.save(watch);
 411
 412         WatchPolicyNotificationTable watch2 = new WatchPolicyNotificationTable();
 413         watch2.setLoginIds(userId);
 414         watch2.setPolicyName("banana2");
 415         commonClassDao.save(watch2);
 416
 417         // SQL Injection attempt
 418         String finalName = "banana' OR '1'='1";
 419
 420         // Current Implementation
 421         String query = "from WatchPolicyNotificationTable where POLICYNAME = :finalName and LOGINIDS = :userId";
 422         SimpleBindings params = new SimpleBindings();
 423         params.put("finalName", finalName);
 424         params.put("userId", userId);
 425         List<Object> dataCur = commonClassDao.getDataByQuery(query, params);
 426
 427         // Assertions
 428         assertTrue(dataCur.size() <= 1);
 429
 430         if (dataCur.size() >= 1) {
 431             assertTrue(dataCur.get(0) instanceof WatchPolicyNotificationTable);
 432             assertFalse(watch.equals(dataCur.get(0)));
 433             assertFalse(watch.equals(dataCur.get(0)));
 434         }
 435     }
 436
 437     @Test
 438     public void testCommonClassDaoImplMethods() {
 439         UserInfo userInfo = new UserInfo();
 440         userInfo.setUserLoginId("TestID");
 441         userInfo.setUserName("Test");
 442         commonClassDao.save(userInfo);
 443         List<Object> data = commonClassDao.getDataById(UserInfo.class, "userLoginId:userName", "TestID:Test");
 444         assertTrue(data.size() == 1);
 445         UserInfo userInfoUpdate = (UserInfo) data.get(0);
 446         userInfoUpdate.setUserName("Test1");
 447         commonClassDao.update(userInfoUpdate);
 448         List<String> data1 = commonClassDao.getDataByColumn(UserInfo.class, "userLoginId");
 449         assertTrue(data1.size() == 1);
 450         UserInfo data2 = (UserInfo) commonClassDao.getEntityItem(UserInfo.class, "userLoginId:userName",
 451                         "TestID:Test1");
 452         assertTrue("TestID".equals(data2.getUserLoginId()));
 453         List<Object> data3 = commonClassDao.checkDuplicateEntry("TestID:Test1", "userLoginId:userName", UserInfo.class);
 454         assertTrue(data3.size() == 1);
 455         PolicyRoles roles = new PolicyRoles();
 456         roles.setRole("admin");
 457         roles.setLoginId(userInfo);
 458         roles.setScope("test");
 459         commonClassDao.save(roles);
 460         List<PolicyRoles> roles1 = commonClassDao.getUserRoles();
 461         assertTrue(roles1.size() == 1);
 462         List<String> multipleData = new ArrayList<>();
 463         multipleData.add("TestID:Test1");
 464         List<Object> data4 = commonClassDao.getMultipleDataOnAddingConjunction(UserInfo.class, "userLoginId:userName",
 465                         multipleData);
 466         assertTrue(data4.size() == 1);
 467         commonClassDao.delete(data2);
 468     }
 469
 470     @Test
 471     public void testGetDataByIdparameters() {
 472         UserInfo userInfo = new UserInfo();
 473         userInfo.setUserLoginId("TestID");
 474         userInfo.setUserName("Test");
 475         commonClassDao.save(userInfo);
 476         List<Object> data = commonClassDao.getDataById(UserInfo.class, "userLoginId:userName", "TestID:Test");
 477         assertTrue(data.size() == 1);
 478         data = commonClassDao.getDataById(UserInfo.class, null, null);
 479         assertNull(data);
 480         data = commonClassDao.getDataById(UserInfo.class, "userLoginId:userName", null);
 481         assertNull(data);
 482         data = commonClassDao.getDataById(UserInfo.class, null, "TestID:Test");
 483         assertNull(data);
 484         data = commonClassDao.getDataById(UserInfo.class, "userLoginIduserName", "TestID:Test");
 485         assertNull(data);
 486         data = commonClassDao.getDataById(UserInfo.class, "userLoginIduserName", "TestIDTest");
 487         assertNull(data);
 488         data = commonClassDao.getDataById(UserInfo.class, "userLoginId   data2.getUserLoginId()" + ":userName",
 489                         "TestIDTest");
 490         assertNull(data);
 491         commonClassDao.delete(data);
 492     }
 493
 494     @Test
 495     public void testGetDataByColumnParameters() {
 496         UserInfo userInfo = new UserInfo();
 497         userInfo.setUserLoginId("TestID");
 498         userInfo.setUserName("Test");
 499         commonClassDao.save(userInfo);
 500         List<String> data = commonClassDao.getDataByColumn(UserInfo.class, "userLoginId");
 501         assertTrue(data.size() == 1);
 502         data = commonClassDao.getDataByColumn(null, null);
 503         assertNull(data);
 504         data = commonClassDao.getDataByColumn(UserInfo.class, null);
 505         assertNull(data);
 506         data = commonClassDao.getDataByColumn(null, "userLoginId");
 507         assertNull(data);
 508         commonClassDao.delete(data);
 509     }
 510
 511     @Test
 512     public void testGetMultipleDataOnAddingConjunctionParameters() {
 513         UserInfo userInfo = new UserInfo();
 514         userInfo.setUserLoginId("TestID");
 515         userInfo.setUserName("Test");
 516         assertEquals("Test", userInfo.getIdentiferByUserId().getUri().getPath());
 517         commonClassDao.save(userInfo);
 518         List<String> multipleData = new ArrayList<>();
 519         multipleData.add("TestID:Test1");
 520         List<Object> data = commonClassDao.getMultipleDataOnAddingConjunction(UserInfo.class, "userLoginId:userName",
 521                         multipleData);
 522         assertTrue(data.size() == 0);
 523         data = commonClassDao.getMultipleDataOnAddingConjunction(null, null, null);
 524         assertNull(data);
 525         data = commonClassDao.getMultipleDataOnAddingConjunction(null, null, multipleData);
 526         assertNull(data);
 527         data = commonClassDao.getMultipleDataOnAddingConjunction(null, "userLoginId:userName", null);
 528         assertNull(data);
 529         data = commonClassDao.getMultipleDataOnAddingConjunction(null, "userLoginId:userName", multipleData);
 530         assertNull(data);
 531         data = commonClassDao.getMultipleDataOnAddingConjunction(UserInfo.class, null, null);
 532         assertNull(data);
 533         data = commonClassDao.getMultipleDataOnAddingConjunction(UserInfo.class, null, multipleData);
 534         assertNull(data);
 535         data = commonClassDao.getMultipleDataOnAddingConjunction(UserInfo.class, "userLoginId:userName", null);
 536         assertNull(data);
 537         commonClassDao.delete(data);
 538     }
 539
 540     @Test
 541     public void testCheckDuplicateEntryParameters() {
 542         UserInfo userInfo = new UserInfo();
 543         userInfo.setUserLoginId("TestID");
 544         userInfo.setUserName("Test");
 545         commonClassDao.save(userInfo);
 546         List<Object> data = commonClassDao.checkDuplicateEntry("TestID:Test1", "userLoginId:userName", UserInfo.class);
 547         assertTrue(data.size() == 0);
 548         data = commonClassDao.checkDuplicateEntry(null, null, UserInfo.class);
 549         assertNull(data);
 550         data = commonClassDao.checkDuplicateEntry("userLoginId:userName", null, UserInfo.class);
 551         assertNull(data);
 552         data = commonClassDao.checkDuplicateEntry(null, "TestID:Test", UserInfo.class);
 553         assertNull(data);
 554         data = commonClassDao.checkDuplicateEntry("userLoginIduserName", "TestID:Test", UserInfo.class);
 555         assertNull(data);
 556         data = commonClassDao.checkDuplicateEntry("userLoginId:userName", "TestID:Test:zooby", UserInfo.class);
 557         assertNull(data);
 558         data = commonClassDao.checkDuplicateEntry("userLoginId:userName", "TestID", UserInfo.class);
 559         assertNull(data);
 560         commonClassDao.delete(data);
 561     }
 562
 563     @Test
 564     public void testGetEntityItemParameters() {
 565         UserInfo userInfo = new UserInfo();
 566         userInfo.setUserLoginId("TestID");
 567         userInfo.setUserName("Test");
 568         commonClassDao.save(userInfo);
 569         List<Object> data = commonClassDao.getDataById(UserInfo.class, "userLoginId:userName", "TestID:Test");
 570         assertTrue(data.size() == 1);
 571         UserInfo userInfoUpdate = (UserInfo) data.get(0);
 572         userInfoUpdate.setUserName("Test1");
 573         commonClassDao.update(userInfoUpdate);
 574         List<String> data1 = commonClassDao.getDataByColumn(UserInfo.class, "userLoginId");
 575         assertTrue(data1.size() == 1);
 576         UserInfo data2 = (UserInfo) commonClassDao.getEntityItem(UserInfo.class, "userLoginId:userName",
 577                         "TestID:Test1");
 578         assertTrue("TestID".equals(data2.getUserLoginId()));
 579         data2 = (UserInfo) commonClassDao.getEntityItem(null, null, null);
 580         assertNull(data2);
 581         data2 = (UserInfo) commonClassDao.getEntityItem(null, null, "TestID:Test1");
 582         assertNull(data2);
 583         data2 = (UserInfo) commonClassDao.getEntityItem(null, "userLoginId:userName", null);
 584         assertNull(data2);
 585         data2 = (UserInfo) commonClassDao.getEntityItem(null, "userLoginId:userName", "TestID:Test1");
 586         assertNull(data2);
 587         data2 = (UserInfo) commonClassDao.getEntityItem(UserInfo.class, null, null);
 588         assertNull(data2);
 589         data2 = (UserInfo) commonClassDao.getEntityItem(UserInfo.class, null, "TestID:Test1");
 590         assertNull(data2);
 591         data2 = (UserInfo) commonClassDao.getEntityItem(UserInfo.class, "userLoginId:userName", null);
 592         assertNull(data2);
 593         data2 = (UserInfo) commonClassDao.getEntityItem(UserInfo.class, "userLoginIduserName", "TestID:Test1");
 594         assertNull(data2);
 595         data2 = (UserInfo) commonClassDao.getEntityItem(UserInfo.class, "userLoginId:userName", "TestIDTest1");
 596         assertNull(data2);
 597         commonClassDao.delete(data);
 598         commonClassDao.delete(data1);
 599         commonClassDao.delete(data2);
 600     }
 601
 602     @Test
 603     public void testOtherMethods() {
 604         UserInfo userInfo = new UserInfo();
 605         userInfo.setUserLoginId("TestID");
 606         userInfo.setUserName("Test");
 607         commonClassDao.save(userInfo);
 608         commonClassDao.deleteAll();
 609         List<Object> data = commonClassDao.getDataById(UserInfo.class, "userLoginId:userName", "TestID:Test");
 610         assertTrue(data.size() == 1);
 611
 612         data = commonClassDao.checkExistingGroupListforUpdate(null, null);
 613         assertTrue(data.size() == 0);
 614
 615         commonClassDao.updateClAlarms(null, null);
 616         commonClassDao.updateClYaml(null, null);
 617         data = commonClassDao.getDataById(UserInfo.class, "userLoginId:userName", "TestID:Test");
 618         assertTrue(data.size() == 1);
 619         commonClassDao.update(null);
 620         assertTrue(data.size() == 1);
 621         commonClassDao.getData(null);
 622         assertTrue(data.size() == 1);
 623         commonClassDao.delete(data);
 624     }
 625
 626     @Test
 627     public void testUpdateQuery() {
 628         UserInfo userInfo = new UserInfo();
 629         userInfo.setUserLoginId("TestID");
 630         userInfo.setUserName("Test");
 631         commonClassDao.save(userInfo);
 632         commonClassDao.updateQuery("SELECT * FROM userLoginId");
 633         List<Object> data = commonClassDao.getDataById(UserInfo.class, "userLoginId:userName", "TestID:Test");
 634         assertTrue(data.size() == 1);
 635
 636         String query = "DELETE FROM org.onap.policy.rest.jpa.FunctionDefinition";
 637         commonClassDao.updateQuery(query);
 638         data = commonClassDao.getDataById(UserInfo.class, "userLoginId:userName", "TestID:Test");
 639         assertTrue(data.size() == 1);
 640         commonClassDao.delete(data);
 641     }
 642
 643     @Test
 644     public void testGetDataByQueryParameters() {
 645         // Add data
 646         UserInfo userinfo = new UserInfo();
 647         String loginIdUserName = "Test";
 648         userinfo.setUserLoginId(loginIdUserName);
 649         userinfo.setUserName(loginIdUserName);
 650         commonClassDao.save(userinfo);
 651
 652         SimpleBindings bindings = new SimpleBindings();
 653         bindings.put("usercode", 1L);
 654
 655         try {
 656             commonClassDao.getDataByQuery("from UserInfo", bindings);
 657             fail("test should throw an exception here");
 658         } catch (Exception exc) {
 659             assertTrue(exc.getMessage().contains("Parameter usercode does not exist as a named parameter"));
 660         }
 661     }
 662
 663     private void truncateAllTables() {
 664         Session session = sessionFactory.openSession();
 665         Transaction transaction = session.beginTransaction();
 666         sessionFactory.getAllClassMetadata().forEach((tableName, x) -> {
 667             Query query = session.createQuery("DELETE FROM " + tableName);
 668             query.executeUpdate();
 669         });
 670         transaction.commit();
 671         session.close();
 672     }
 673 }