2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
6 * ================================================================================
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 * ============LICENSE_END=========================================================
21 package org.onap.policy.pap.ia;
23 import static org.junit.Assert.assertEquals;
24 import static org.junit.Assert.assertTrue;
26 import java.util.Date;
27 import java.util.HashMap;
28 import java.util.Properties;
31 import javax.persistence.EntityManager;
32 import javax.persistence.EntityManagerFactory;
33 import javax.persistence.EntityTransaction;
34 import javax.persistence.Persistence;
36 import org.apache.commons.lang3.SerializationUtils;
37 import org.apache.commons.logging.Log;
38 import org.apache.commons.logging.LogFactory;
39 import org.junit.After;
40 import org.junit.Before;
41 import org.junit.Test;
42 import org.onap.policy.common.ia.DbAudit;
43 import org.onap.policy.common.ia.DbDAO;
44 import org.onap.policy.common.ia.IntegrityAuditProperties;
45 import org.onap.policy.common.ia.jpa.IntegrityAuditEntity;
46 import org.onap.policy.common.im.jpa.ForwardProgressEntity;
47 import org.onap.policy.common.im.jpa.ResourceRegistrationEntity;
48 import org.onap.policy.common.im.jpa.StateManagementEntity;
49 import org.onap.policy.jpa.BackUpMonitorEntity;
51 public class DbAuditCompareEntriesTest {
53 private static Log logger = LogFactory.getLog(DbAuditCompareEntriesTest.class);
55 private String persistenceUnit;
56 private Properties properties;
57 private String resourceName;
58 private String dbDriver;
60 private String dbUser;
62 private String siteName;
63 private String nodeType;
64 private static final String DEFAULT_DB_DRIVER = "org.h2.Driver";
65 private static final String DEFAULT_DB_USER = "sa";
66 private static final String DEFAULT_DB_PWD = "";
69 public void setUp() throws Exception {
70 logger.info("setUp: Entering");
72 properties = new Properties();
73 properties.put(IntegrityAuditProperties.DB_DRIVER, DbAuditCompareEntriesTest.DEFAULT_DB_DRIVER);
74 properties.put(IntegrityAuditProperties.DB_URL, "jdbc:h2:file:./sql/xacmlTest");
75 properties.put(IntegrityAuditProperties.DB_USER, DbAuditCompareEntriesTest.DEFAULT_DB_USER);
76 properties.put(IntegrityAuditProperties.DB_PWD, DbAuditCompareEntriesTest.DEFAULT_DB_PWD);
77 properties.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
78 properties.put(IntegrityAuditProperties.NODE_TYPE, "pap");
80 dbDriver = DbAuditCompareEntriesTest.DEFAULT_DB_DRIVER;
81 dbUrl = "jdbc:h2:file:./sql/xacmlTest";
82 dbUser = DbAuditCompareEntriesTest.DEFAULT_DB_USER;
83 dbPwd = DbAuditCompareEntriesTest.DEFAULT_DB_PWD;
86 persistenceUnit = "testPapPU";
87 resourceName = "siteA.pap1";
89 //Clean the iaTest DB table for IntegrityAuditEntity entries
90 cleanDb(persistenceUnit, properties);
92 logger.info("setUp: Exiting");
96 public void tearDown() throws Exception {
97 logger.info("tearDown: Entering");
99 logger.info("tearDown: Exiting");
102 public void cleanDb(String persistenceUnit, Properties properties){
103 logger.debug("cleanDb: enter");
105 EntityManagerFactory emf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
107 EntityManager em = emf.createEntityManager();
108 // Start a transaction
109 EntityTransaction et = em.getTransaction();
114 em.createQuery("Delete from IntegrityAuditEntity").executeUpdate();
116 // commit transaction
119 logger.debug("cleanDb: exit");
124 * Tests that a comparison between hashsets is successful if
128 public void runAllTests() throws Exception {
129 logger.info("runAllTests: Entering");
132 testIntegrityAuditEntity();
133 testBackupMonitorEntity();
134 testStateManagementEntity();
135 testForwardProgressEntity();
136 testResourceRegistrationEntity();
138 //clean up the IntegrityAuditEntity table
139 cleanDb(persistenceUnit, properties);
141 logger.info("runAllTests: Exit");
145 public void testIntegrityAuditEntity() throws Exception {
146 logger.info("testIntegrityAuditEntity: Entering");
148 dbDAO = new DbDAO(resourceName, persistenceUnit, properties);
149 DbAudit dbAudit = new DbAudit(dbDAO);
151 String className = null;
152 //There is only one entry IntegrityAuditEntity, but we will check anyway
153 Set<String> classNameSet = dbDAO.getPersistenceClassNames();
154 for(String c : classNameSet){
155 if (c.equals("org.onap.policy.common.ia.jpa.IntegrityAuditEntity")){
159 String resourceName1 = resourceName;
160 String resourceName2 = resourceName;
162 IntegrityAuditEntity entry1 = new IntegrityAuditEntity();
163 IntegrityAuditEntity entry2 = new IntegrityAuditEntity();
164 Date date = new Date();
167 * Two entries with the same field values
169 entry1.setDesignated(false);
170 entry1.setJdbcDriver(dbDriver);
171 entry1.setJdbcPassword(dbPwd);
172 entry1.setJdbcUrl(dbUrl);
173 entry1.setJdbcUser(dbUser);
174 entry1.setLastUpdated(date);
175 entry1.setNodeType(nodeType);
176 entry1.setPersistenceUnit(persistenceUnit);
177 entry1.setResourceName(resourceName1);
178 entry1.setSite(siteName);
180 entry2 = SerializationUtils.clone(entry1);
182 dbAudit.writeAuditDebugLog(className, resourceName1, resourceName2, entry1, entry2);
184 HashMap<Object, Object> myEntries = new HashMap<>();
185 HashMap<Object, Object> theirEntries = new HashMap<>();
187 myEntries.put("pdp1", entry1);
188 theirEntries.put("pdp1", entry2);
190 Set<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
193 * Assert that there are no mismatches returned
195 assertTrue(result.isEmpty());
198 * ************************************
199 * Now test with a mis-matched entry
200 * ************************************
204 * Change the entry2 to different designated value
206 entry2.setDesignated(true);
208 myEntries = new HashMap<>();
209 theirEntries = new HashMap<>();
211 myEntries.put("pdp1", entry1);
212 theirEntries.put("pdp1", entry2);
214 result = dbAudit.compareEntries(myEntries, theirEntries);
217 * Assert that there was one mismatch
219 assertEquals(1, result.size());
220 logger.info("testIntegrityAuditEntity: Exit");
223 void testBackupMonitorEntity() throws Exception {
224 logger.info("testBackupMonitorEntity: Entering");
226 dbDAO = new DbDAO(resourceName, persistenceUnit, properties);
227 DbAudit dbAudit = new DbAudit(dbDAO);
229 BackUpMonitorEntity entry1 = new BackUpMonitorEntity();
230 BackUpMonitorEntity entry2 = new BackUpMonitorEntity();
232 // Two entries with the same field values
235 entry1.setFlag("flag1");
236 entry1.setResourceNodeName("node1");
237 entry1.setResourceName("resourceName");
238 entry1.setTimeStamp(new Date());
240 // Clone the first entry
241 entry2 = SerializationUtils.clone(entry1);
243 HashMap<Object, Object> myEntries = new HashMap<>();
244 HashMap<Object, Object> theirEntries = new HashMap<>();
246 myEntries.put("pdp1", entry1);
247 theirEntries.put("pdp1", entry2);
249 Set<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
252 // Assert that there are no mismatches returned
254 assertTrue(result.isEmpty());
257 /* ************************************
258 * Now test with a mis-matched entry
259 * ************************************/
263 // Change a field on entry2
265 entry2.setFlag("flag2");
267 myEntries = new HashMap<>();
268 theirEntries = new HashMap<>();
270 myEntries.put("pdp1", entry1);
271 theirEntries.put("pdp1", entry2);
273 result = dbAudit.compareEntries(myEntries, theirEntries);
276 //Assert that there was one mismatch
278 assertEquals(1, result.size());
279 logger.info("testBackupMonitorEntity: Exit");
282 void testStateManagementEntity() throws Exception {
283 logger.info("testStateManagementEntity: Entering");
285 dbDAO = new DbDAO(resourceName, persistenceUnit, properties);
286 DbAudit dbAudit = new DbAudit(dbDAO);
288 StateManagementEntity entry1 = new StateManagementEntity();
289 StateManagementEntity entry2 = new StateManagementEntity();
291 // Two entries with the same field values
293 entry1.setAdminState("locked");
294 entry1.setAvailStatus("null");
295 entry1.setModifiedDate(new Date());
296 entry1.setOpState("enabled");
297 entry1.setResourceName("myResource");
298 entry1.setStandbyStatus("coldstandby");
300 // Clone the first entry
301 entry2 = SerializationUtils.clone(entry1);
303 HashMap<Object, Object> myEntries = new HashMap<>();
304 HashMap<Object, Object> theirEntries = new HashMap<>();
306 myEntries.put("pdp1", entry1);
307 theirEntries.put("pdp1", entry2);
309 Set<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
312 // Assert that there are no mismatches returned
314 assertTrue(result.isEmpty());
317 /* ************************************
318 * Now test with a mis-matched entry
319 * ************************************/
323 // Change a field on entry2
325 entry2.setAdminState("unlocked");
327 myEntries = new HashMap<>();
328 theirEntries = new HashMap<>();
330 myEntries.put("pdp1", entry1);
331 theirEntries.put("pdp1", entry2);
333 result = dbAudit.compareEntries(myEntries, theirEntries);
336 //Assert that there was one mismatch
338 assertEquals(1, result.size());
339 logger.info("testStateManagementEntity: Exit");
342 void testForwardProgressEntity() throws Exception {
343 logger.info("testForwardProgressEntity: Entering");
345 dbDAO = new DbDAO(resourceName, persistenceUnit, properties);
346 DbAudit dbAudit = new DbAudit(dbDAO);
348 ForwardProgressEntity entry1 = new ForwardProgressEntity();
349 ForwardProgressEntity entry2 = new ForwardProgressEntity();
351 // Two entries with the same field values
353 entry1.setFpcCount(123L);
354 entry1.setLastUpdated(new Date());
355 entry1.setResourceName("myResource");
357 // Clone the first entry
358 entry2 = SerializationUtils.clone(entry1);
360 HashMap<Object, Object> myEntries = new HashMap<Object, Object>();
361 HashMap<Object, Object> theirEntries = new HashMap<Object, Object>();
363 myEntries.put("pdp1", entry1);
364 theirEntries.put("pdp1", entry2);
366 Set<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
369 // Assert that there are no mismatches returned
371 assertTrue(result.isEmpty());
374 /* ************************************
375 * Now test with a mis-matched entry
376 * ************************************/
378 // Change a field on entry2
380 entry2.setFpcCount(321L);
382 myEntries = new HashMap<>();
383 theirEntries = new HashMap<>();
385 myEntries.put("pdp1", entry1);
386 theirEntries.put("pdp1", entry2);
388 result = dbAudit.compareEntries(myEntries, theirEntries);
391 //Assert that there was one mismatch
393 assertEquals(1, result.size());
394 logger.info("testForwardProgressEntity: Exit");
397 void testResourceRegistrationEntity() throws Exception {
398 logger.info("testResourceRegistrationEntity: Entering");
400 dbDAO = new DbDAO(resourceName, persistenceUnit, properties);
401 DbAudit dbAudit = new DbAudit(dbDAO);
403 ResourceRegistrationEntity entry1 = new ResourceRegistrationEntity();
404 ResourceRegistrationEntity entry2 = new ResourceRegistrationEntity();
406 // Two entries with the same field values
408 entry1.setNodeType("pap");
409 entry1.setLastUpdated(new Date());
410 entry1.setResourceName("myResource");
411 entry1.setResourceUrl("http://nowhere.com");
412 entry1.setSite("site_1");
414 // Clone the first entry
415 entry2 = SerializationUtils.clone(entry1);
417 HashMap<Object, Object> myEntries = new HashMap<>();
418 HashMap<Object, Object> theirEntries = new HashMap<>();
420 myEntries.put("pdp1", entry1);
421 theirEntries.put("pdp1", entry2);
423 Set<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
426 // Assert that there are no mismatches returned
428 assertTrue(result.isEmpty());
431 /* ************************************
432 * Now test with a mis-matched entry
433 * ************************************/
435 // Change a field on entry2
437 entry2.setSite("site_1a");
439 myEntries = new HashMap<>();
440 theirEntries = new HashMap<>();
442 myEntries.put("pdp1", entry1);
443 theirEntries.put("pdp1", entry2);
445 result = dbAudit.compareEntries(myEntries, theirEntries);
448 //Assert that there was one mismatch
450 assertEquals(1, result.size());
451 logger.info("testResourceRegistrationEntity: Exit");