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.openecomp.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.HashSet;
29 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.openecomp.policy.common.ia.DbAudit;
43 import org.openecomp.policy.common.ia.DbDAO;
44 import org.openecomp.policy.common.ia.IntegrityAuditProperties;
45 import org.openecomp.policy.common.ia.jpa.IntegrityAuditEntity;
46 import org.openecomp.policy.common.im.jpa.ForwardProgressEntity;
47 import org.openecomp.policy.common.im.jpa.ResourceRegistrationEntity;
48 import org.openecomp.policy.common.im.jpa.StateManagementEntity;
49 import org.openecomp.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;
66 public void setUp() throws Exception {
67 logger.info("setUp: Entering");
69 properties = new Properties();
70 properties.put(IntegrityAuditProperties.DB_DRIVER, IntegrityAuditProperties.DEFAULT_DB_DRIVER);
71 properties.put(IntegrityAuditProperties.DB_URL, "jdbc:h2:file:./sql/xacmlTest");
72 properties.put(IntegrityAuditProperties.DB_USER, IntegrityAuditProperties.DEFAULT_DB_USER);
73 properties.put(IntegrityAuditProperties.DB_PWD, IntegrityAuditProperties.DEFAULT_DB_PWD);
74 properties.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
75 properties.put(IntegrityAuditProperties.NODE_TYPE, "pap");
77 dbDriver = IntegrityAuditProperties.DEFAULT_DB_DRIVER;
78 dbUrl = "jdbc:h2:file:./sql/xacmlTest";
79 dbUser = IntegrityAuditProperties.DEFAULT_DB_USER;
80 dbPwd = IntegrityAuditProperties.DEFAULT_DB_PWD;
83 persistenceUnit = "testPapPU";
84 resourceName = "siteA.pap1";
86 //Clean the iaTest DB table for IntegrityAuditEntity entries
87 cleanDb(persistenceUnit, properties);
89 logger.info("setUp: Exiting");
93 public void tearDown() throws Exception {
94 logger.info("tearDown: Entering");
96 logger.info("tearDown: Exiting");
99 public void cleanDb(String persistenceUnit, Properties properties){
100 logger.debug("cleanDb: enter");
102 EntityManagerFactory emf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
104 EntityManager em = emf.createEntityManager();
105 // Start a transaction
106 EntityTransaction et = em.getTransaction();
111 em.createQuery("Delete from IntegrityAuditEntity").executeUpdate();
113 // commit transaction
116 logger.debug("cleanDb: exit");
121 * Tests that a comparison between hashsets is successful if
125 public void runAllTests() throws Exception {
126 logger.info("runAllTests: Entering");
129 testIntegrityAuditEntity();
130 testBackupMonitorEntity();
131 testStateManagementEntity();
132 testForwardProgressEntity();
133 testResourceRegistrationEntity();
135 //clean up the IntegrityAuditEntity table
136 cleanDb(persistenceUnit, properties);
138 logger.info("runAllTests: Exit");
142 public void testIntegrityAuditEntity() throws Exception {
143 logger.info("testIntegrityAuditEntity: Entering");
145 dbDAO = new DbDAO(resourceName, persistenceUnit, properties);
146 DbAudit dbAudit = new DbAudit(dbDAO);
148 String className = null;
149 //There is only one entry IntegrityAuditEntity, but we will check anyway
150 HashSet<String> classNameSet = dbDAO.getPersistenceClassNames();
151 for(String c : classNameSet){
152 if (c.equals("org.openecomp.policy.common.ia.jpa.IntegrityAuditEntity")){
156 String resourceName1 = resourceName;
157 String resourceName2 = resourceName;
159 IntegrityAuditEntity entry1 = new IntegrityAuditEntity();
160 IntegrityAuditEntity entry2 = new IntegrityAuditEntity();
161 Date date = new Date();
164 * Two entries with the same field values
166 entry1.setDesignated(false);
167 entry1.setJdbcDriver(dbDriver);
168 entry1.setJdbcPassword(dbPwd);
169 entry1.setJdbcUrl(dbUrl);
170 entry1.setJdbcUser(dbUser);
171 entry1.setLastUpdated(date);
172 entry1.setNodeType(nodeType);
173 entry1.setPersistenceUnit(persistenceUnit);
174 entry1.setResourceName(resourceName1);
175 entry1.setSite(siteName);
177 entry2 = SerializationUtils.clone(entry1);
179 dbAudit.writeAuditDebugLog(className, resourceName1, resourceName2, entry1, entry2);
181 HashMap<Object, Object> myEntries = new HashMap<>();
182 HashMap<Object, Object> theirEntries = new HashMap<>();
184 myEntries.put("pdp1", entry1);
185 theirEntries.put("pdp1", entry2);
187 HashSet<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
190 * Assert that there are no mismatches returned
192 assertTrue(result.isEmpty());
195 * ************************************
196 * Now test with a mis-matched entry
197 * ************************************
201 * Change the entry2 to different designated value
203 entry2.setDesignated(true);
205 myEntries = new HashMap<>();
206 theirEntries = new HashMap<>();
208 myEntries.put("pdp1", entry1);
209 theirEntries.put("pdp1", entry2);
211 result = dbAudit.compareEntries(myEntries, theirEntries);
214 * Assert that there was one mismatch
216 assertEquals(1, result.size());
217 logger.info("testIntegrityAuditEntity: Exit");
220 void testBackupMonitorEntity() throws Exception {
221 logger.info("testBackupMonitorEntity: Entering");
223 dbDAO = new DbDAO(resourceName, persistenceUnit, properties);
224 DbAudit dbAudit = new DbAudit(dbDAO);
226 BackUpMonitorEntity entry1 = new BackUpMonitorEntity();
227 BackUpMonitorEntity entry2 = new BackUpMonitorEntity();
229 // Two entries with the same field values
232 entry1.setFlag("flag1");
233 entry1.setResoruceNodeName("node1");
234 entry1.setResourceName("resourceName");
235 entry1.setTimeStamp(new Date());
237 // Clone the first entry
238 entry2 = SerializationUtils.clone(entry1);
240 HashMap<Object, Object> myEntries = new HashMap<>();
241 HashMap<Object, Object> theirEntries = new HashMap<>();
243 myEntries.put("pdp1", entry1);
244 theirEntries.put("pdp1", entry2);
246 HashSet<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
249 // Assert that there are no mismatches returned
251 assertTrue(result.isEmpty());
254 /* ************************************
255 * Now test with a mis-matched entry
256 * ************************************/
260 // Change a field on entry2
262 entry2.setFlag("flag2");
264 myEntries = new HashMap<>();
265 theirEntries = new HashMap<>();
267 myEntries.put("pdp1", entry1);
268 theirEntries.put("pdp1", entry2);
270 result = dbAudit.compareEntries(myEntries, theirEntries);
273 //Assert that there was one mismatch
275 assertEquals(1, result.size());
276 logger.info("testBackupMonitorEntity: Exit");
279 void testStateManagementEntity() throws Exception {
280 logger.info("testStateManagementEntity: Entering");
282 dbDAO = new DbDAO(resourceName, persistenceUnit, properties);
283 DbAudit dbAudit = new DbAudit(dbDAO);
285 StateManagementEntity entry1 = new StateManagementEntity();
286 StateManagementEntity entry2 = new StateManagementEntity();
288 // Two entries with the same field values
290 entry1.setAdminState("locked");
291 entry1.setAvailStatus("null");
292 entry1.setModifiedDate(new Date());
293 entry1.setOpState("enabled");
294 entry1.setResourceName("myResource");
295 entry1.setStandbyStatus("coldstandby");
297 // Clone the first entry
298 entry2 = SerializationUtils.clone(entry1);
300 HashMap<Object, Object> myEntries = new HashMap<>();
301 HashMap<Object, Object> theirEntries = new HashMap<>();
303 myEntries.put("pdp1", entry1);
304 theirEntries.put("pdp1", entry2);
306 HashSet<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
309 // Assert that there are no mismatches returned
311 assertTrue(result.isEmpty());
314 /* ************************************
315 * Now test with a mis-matched entry
316 * ************************************/
320 // Change a field on entry2
322 entry2.setAdminState("unlocked");
324 myEntries = new HashMap<>();
325 theirEntries = new HashMap<>();
327 myEntries.put("pdp1", entry1);
328 theirEntries.put("pdp1", entry2);
330 result = dbAudit.compareEntries(myEntries, theirEntries);
333 //Assert that there was one mismatch
335 assertEquals(1, result.size());
336 logger.info("testStateManagementEntity: Exit");
339 void testForwardProgressEntity() throws Exception {
340 logger.info("testForwardProgressEntity: Entering");
342 dbDAO = new DbDAO(resourceName, persistenceUnit, properties);
343 DbAudit dbAudit = new DbAudit(dbDAO);
345 ForwardProgressEntity entry1 = new ForwardProgressEntity();
346 ForwardProgressEntity entry2 = new ForwardProgressEntity();
348 // Two entries with the same field values
350 entry1.setFpcCount(123L);
351 entry1.setLastUpdated(new Date());
352 entry1.setResourceName("myResource");
354 // Clone the first entry
355 entry2 = SerializationUtils.clone(entry1);
357 HashMap<Object, Object> myEntries = new HashMap<Object, Object>();
358 HashMap<Object, Object> theirEntries = new HashMap<Object, Object>();
360 myEntries.put("pdp1", entry1);
361 theirEntries.put("pdp1", entry2);
363 HashSet<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
366 // Assert that there are no mismatches returned
368 assertTrue(result.isEmpty());
371 /* ************************************
372 * Now test with a mis-matched entry
373 * ************************************/
375 // Change a field on entry2
377 entry2.setFpcCount(321L);
379 myEntries = new HashMap<>();
380 theirEntries = new HashMap<>();
382 myEntries.put("pdp1", entry1);
383 theirEntries.put("pdp1", entry2);
385 result = dbAudit.compareEntries(myEntries, theirEntries);
388 //Assert that there was one mismatch
390 assertEquals(1, result.size());
391 logger.info("testForwardProgressEntity: Exit");
394 void testResourceRegistrationEntity() throws Exception {
395 logger.info("testResourceRegistrationEntity: Entering");
397 dbDAO = new DbDAO(resourceName, persistenceUnit, properties);
398 DbAudit dbAudit = new DbAudit(dbDAO);
400 ResourceRegistrationEntity entry1 = new ResourceRegistrationEntity();
401 ResourceRegistrationEntity entry2 = new ResourceRegistrationEntity();
403 // Two entries with the same field values
405 entry1.setNodeType("pap");
406 entry1.setLastUpdated(new Date());
407 entry1.setResourceName("myResource");
408 entry1.setResourceUrl("http://nowhere.com");
409 entry1.setSite("site_1");
411 // Clone the first entry
412 entry2 = SerializationUtils.clone(entry1);
414 HashMap<Object, Object> myEntries = new HashMap<>();
415 HashMap<Object, Object> theirEntries = new HashMap<>();
417 myEntries.put("pdp1", entry1);
418 theirEntries.put("pdp1", entry2);
420 HashSet<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
423 // Assert that there are no mismatches returned
425 assertTrue(result.isEmpty());
428 /* ************************************
429 * Now test with a mis-matched entry
430 * ************************************/
432 // Change a field on entry2
434 entry2.setSite("site_1a");
436 myEntries = new HashMap<>();
437 theirEntries = new HashMap<>();
439 myEntries.put("pdp1", entry1);
440 theirEntries.put("pdp1", entry2);
442 result = dbAudit.compareEntries(myEntries, theirEntries);
445 //Assert that there was one mismatch
447 assertEquals(1, result.size());
448 logger.info("testResourceRegistrationEntity: Exit");