2 * ============LICENSE_START=======================================================
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
13 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
23 package org.onap.policy.rest.daoimpl;
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;
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;
40 import javax.script.SimpleBindings;
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;
65 public class PolicyValidationDaoImplTest {
67 private static Logger logger = FlexLogger.getLogger(PolicyValidationDaoImplTest.class);
69 static SessionFactory sessionFactory;
71 static PolicyValidationDaoImpl commonClassDao;
74 * Set up all unit tests.
76 * @throws SQLException on SQL exceptions
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.*");
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");
95 sessionBuilder.addProperties(properties);
96 sessionFactory = sessionBuilder.buildSessionFactory();
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");
116 // Create TCP server for troubleshooting
117 server = Server.createTcpServer("-tcpAllowOthers").start();
118 System.out.println("URL: jdbc:h2:" + server.getURL() + "/mem:test");
122 public static void deleteDB() {
123 sessionFactory.close();
128 public void tearDown() {
135 public void testDB() {
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);
148 List<Object> list = commonClassDao.getData(OnapName.class);
149 assertTrue(list.size() == 1);
150 logger.debug(list.size());
151 logger.debug(list.get(0));
157 public void testUser() {
159 UserInfo userinfo = new UserInfo();
160 String loginIdUserName = "Test";
161 userinfo.setUserLoginId(loginIdUserName);
162 userinfo.setUserName(loginIdUserName);
163 commonClassDao.save(userinfo);
165 List<Object> dataCur = commonClassDao.getDataByQuery("from UserInfo", new SimpleBindings());
167 assertEquals(1, dataCur.size());
168 UserInfo cur = (UserInfo) dataCur.get(0);
169 assertEquals(loginIdUserName, cur.getUserLoginId());
170 assertEquals(loginIdUserName, cur.getUserName());
172 assertFalse(dataCur.isEmpty());
178 public void getDataByQuery_DashboardController() {
180 PolicyEntity pe = new PolicyEntity();
181 String name = "TestPolicy";
182 pe.setPolicyName(name);
183 pe.setPolicyData("dummyData");
185 pe.setScope("dummyScope");
186 pe.setDescription("descr");
187 pe.setDeleted(false);
188 pe.setCreatedBy("Test");
189 commonClassDao.save(pe);
191 List<Object> dataCur = commonClassDao.getDataByQuery("from PolicyEntity", new SimpleBindings());
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)));
202 public void getDataByQuery_AutoPushController() {
204 PolicyVersion pv = new PolicyVersion();
205 pv.setActiveVersion(2);
206 pv.setPolicyName("myPname");
208 pv.setCreatedBy("Test");
209 pv.setModifiedBy("Test");
211 PolicyVersion pv2 = new PolicyVersion();
212 pv2.setActiveVersion(1);
213 pv2.setPolicyName("test");
215 pv2.setCreatedBy("Test");
216 pv2.setModifiedBy("Test");
218 commonClassDao.save(pv);
219 commonClassDao.save(pv2);
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);
228 assertTrue(1 == dataCur.size());
229 assertEquals(pv, dataCur.get(0));
235 public void getDataByQuery_PolicyNotificationMail() {
237 WatchPolicyNotificationTable watch = new WatchPolicyNotificationTable();
238 watch.setLoginIds("Test");
241 UserInfo userinfo = new UserInfo();
242 String loginIdUserName = "Test";
243 userinfo.setUserLoginId(loginIdUserName);
244 userinfo.setUserName(loginIdUserName);
245 commonClassDao.save(userinfo);
247 List<Object> dataCur = commonClassDao.getDataByQuery("from UserInfo", new SimpleBindings());
249 assertEquals(1, dataCur.size());
250 UserInfo cur = (UserInfo) dataCur.get(0);
251 assertEquals(loginIdUserName, cur.getUserLoginId());
252 assertEquals(loginIdUserName, cur.getUserName());
254 assertFalse(dataCur.isEmpty());
256 watch.setPolicyName("bananaWatch");
257 commonClassDao.save(watch);
259 String policyFileName = "banana";
260 if (policyFileName.contains("/")) {
261 policyFileName = policyFileName.substring(0, policyFileName.indexOf("/"));
262 policyFileName = policyFileName.replace("/", File.separator);
264 if (policyFileName.contains("\\")) {
265 policyFileName = policyFileName.substring(0, policyFileName.indexOf("\\"));
266 policyFileName = policyFileName.replace("\\", "\\\\");
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);
277 assertTrue(dataCur.size() == 1);
278 assertTrue(dataCur.get(0) instanceof WatchPolicyNotificationTable);
279 assertEquals(watch, dataCur.get(0));
285 public void getDataByQuery_PolicyController() {
287 PolicyEntity pe = new PolicyEntity();
288 String name = "actionDummy";
289 pe.setPolicyName(name);
290 pe.setPolicyData("dummyData");
292 pe.setScope("dummyScope");
293 pe.setDescription("descr");
294 pe.setDeleted(false);
295 pe.setCreatedBy("Test");
296 commonClassDao.save(pe);
298 String dbCheckName = "dummyScope:action";
299 String[] splitDbCheckName = dbCheckName.split(":");
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);
309 assertTrue(dataCur.size() == 1);
310 assertTrue(dataCur.get(0) instanceof PolicyEntity);
311 assertEquals(pe, dataCur.get(0));
317 public void getDataByQuery_PolicyNotificationController() {
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);
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);
334 assertTrue(dataCur.size() == 1);
335 assertTrue(dataCur.get(0) instanceof WatchPolicyNotificationTable);
336 assertEquals(watch, dataCur.get(0));
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);
348 assertNotEquals(table0, table1);
350 assertEquals(table0, table1);
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);
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);
388 assertNotNull(table0.hashCode());
389 assertNotNull(table1.hashCode());
390 assertEquals(table0.hashCode(), table0.hashCode());
392 table0.setLoginIds("Witci");
393 assertNotEquals(table0, table1);
394 assertNotEquals(table0.hashCode(), table1.hashCode());
398 * Test for SQL Injection Protection
404 public void getDataByQuery_PolicyNotificationController_Injection() {
406 WatchPolicyNotificationTable watch = new WatchPolicyNotificationTable();
407 String userId = "Test";
408 watch.setLoginIds(userId);
409 watch.setPolicyName("banana");
410 commonClassDao.save(watch);
412 WatchPolicyNotificationTable watch2 = new WatchPolicyNotificationTable();
413 watch2.setLoginIds(userId);
414 watch2.setPolicyName("banana2");
415 commonClassDao.save(watch2);
417 // SQL Injection attempt
418 String finalName = "banana' OR '1'='1";
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);
428 assertTrue(dataCur.size() <= 1);
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)));
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",
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",
466 assertTrue(data4.size() == 1);
467 commonClassDao.delete(data2);
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);
480 data = commonClassDao.getDataById(UserInfo.class, "userLoginId:userName", null);
482 data = commonClassDao.getDataById(UserInfo.class, null, "TestID:Test");
484 data = commonClassDao.getDataById(UserInfo.class, "userLoginIduserName", "TestID:Test");
486 data = commonClassDao.getDataById(UserInfo.class, "userLoginIduserName", "TestIDTest");
488 data = commonClassDao.getDataById(UserInfo.class, "userLoginId data2.getUserLoginId()" + ":userName",
491 commonClassDao.delete(data);
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);
504 data = commonClassDao.getDataByColumn(UserInfo.class, null);
506 data = commonClassDao.getDataByColumn(null, "userLoginId");
508 commonClassDao.delete(data);
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",
522 assertTrue(data.size() == 0);
523 data = commonClassDao.getMultipleDataOnAddingConjunction(null, null, null);
525 data = commonClassDao.getMultipleDataOnAddingConjunction(null, null, multipleData);
527 data = commonClassDao.getMultipleDataOnAddingConjunction(null, "userLoginId:userName", null);
529 data = commonClassDao.getMultipleDataOnAddingConjunction(null, "userLoginId:userName", multipleData);
531 data = commonClassDao.getMultipleDataOnAddingConjunction(UserInfo.class, null, null);
533 data = commonClassDao.getMultipleDataOnAddingConjunction(UserInfo.class, null, multipleData);
535 data = commonClassDao.getMultipleDataOnAddingConjunction(UserInfo.class, "userLoginId:userName", null);
537 commonClassDao.delete(data);
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);
550 data = commonClassDao.checkDuplicateEntry("userLoginId:userName", null, UserInfo.class);
552 data = commonClassDao.checkDuplicateEntry(null, "TestID:Test", UserInfo.class);
554 data = commonClassDao.checkDuplicateEntry("userLoginIduserName", "TestID:Test", UserInfo.class);
556 data = commonClassDao.checkDuplicateEntry("userLoginId:userName", "TestID:Test:zooby", UserInfo.class);
558 data = commonClassDao.checkDuplicateEntry("userLoginId:userName", "TestID", UserInfo.class);
560 commonClassDao.delete(data);
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",
578 assertTrue("TestID".equals(data2.getUserLoginId()));
579 data2 = (UserInfo) commonClassDao.getEntityItem(null, null, null);
581 data2 = (UserInfo) commonClassDao.getEntityItem(null, null, "TestID:Test1");
583 data2 = (UserInfo) commonClassDao.getEntityItem(null, "userLoginId:userName", null);
585 data2 = (UserInfo) commonClassDao.getEntityItem(null, "userLoginId:userName", "TestID:Test1");
587 data2 = (UserInfo) commonClassDao.getEntityItem(UserInfo.class, null, null);
589 data2 = (UserInfo) commonClassDao.getEntityItem(UserInfo.class, null, "TestID:Test1");
591 data2 = (UserInfo) commonClassDao.getEntityItem(UserInfo.class, "userLoginId:userName", null);
593 data2 = (UserInfo) commonClassDao.getEntityItem(UserInfo.class, "userLoginIduserName", "TestID:Test1");
595 data2 = (UserInfo) commonClassDao.getEntityItem(UserInfo.class, "userLoginId:userName", "TestIDTest1");
597 commonClassDao.delete(data);
598 commonClassDao.delete(data1);
599 commonClassDao.delete(data2);
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);
612 data = commonClassDao.checkExistingGroupListforUpdate(null, null);
613 assertTrue(data.size() == 0);
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);
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);
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);
644 public void testGetDataByQueryParameters() {
646 UserInfo userinfo = new UserInfo();
647 String loginIdUserName = "Test";
648 userinfo.setUserLoginId(loginIdUserName);
649 userinfo.setUserName(loginIdUserName);
650 commonClassDao.save(userinfo);
652 SimpleBindings bindings = new SimpleBindings();
653 bindings.put("usercode", 1L);
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"));
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();
670 transaction.commit();